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

module Language.Haskell.Liquid.Parse
  ( hsSpecificationP
  , specSpecificationP
  , singleSpecP
  , BPspec
  , Pspec(..)
  , parseSymbolToLogic
  , parseTest'
  )
  where

import           Control.Arrow                          (second)
import           Control.Monad
import           Control.Monad.Identity
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                              (foldl', partition)
import           GHC                                    (ModuleName, mkModuleName)
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
-- import           Language.Haskell.Liquid.Types.Errors
import qualified Language.Fixpoint.Misc                 as Misc
import qualified Language.Haskell.Liquid.Misc           as Misc
import qualified Language.Haskell.Liquid.Measure        as Measure
import           Language.Fixpoint.Parse                hiding (defineP, dataDeclP, refBindP, refP, refDefP, parseTest')

import Control.Monad.State

-- import Debug.Trace

-- * Top-level parsing API

-- | Used to parse .hs and .lhs files (via ApiAnnotations).
hsSpecificationP :: ModuleName
                 -> [(SourcePos, String)]
                 -> [BPspec]
                 -> Either [Error] (ModName, Measure.BareSpec)
hsSpecificationP :: ModuleName
-> [(SourcePos, [Char])]
-> [BPspec]
-> Either [Error] (ModName, BareSpec)
hsSpecificationP ModuleName
modName [(SourcePos, [Char])]
specComments [BPspec]
specQuotes =
  case ([Error], [BPspec])
-> PState -> [(SourcePos, [Char])] -> ([Error], [BPspec])
go ([], []) PState
initPStateWithList [(SourcePos, [Char])]
specComments of
    ([], [BPspec]
specs) ->
      (ModName, BareSpec) -> Either [Error] (ModName, BareSpec)
forall a b. b -> Either a b
Right ((ModName, BareSpec) -> Either [Error] (ModName, BareSpec))
-> (ModName, BareSpec) -> Either [Error] (ModName, BareSpec)
forall a b. (a -> b) -> a -> b
$ ModName -> [BPspec] -> (ModName, BareSpec)
mkSpec (ModType -> ModuleName -> ModName
ModName ModType
SrcImport ModuleName
modName) ([BPspec]
specs [BPspec] -> [BPspec] -> [BPspec]
forall a. [a] -> [a] -> [a]
++ [BPspec]
specQuotes)
    ([Error]
errors, [BPspec]
_) ->
      [Error] -> Either [Error] (ModName, BareSpec)
forall a b. a -> Either a b
Left [Error]
errors
  where
    go :: ([Error], [BPspec])   -- accumulated errors and parsed specs (in reverse order)
       -> PState                -- parser state (primarily infix operator priorities)
       -> [(SourcePos, String)] -- remaining unparsed spec comments
       -> ([Error], [BPspec])   -- final errors and parsed specs
    go :: ([Error], [BPspec])
-> PState -> [(SourcePos, [Char])] -> ([Error], [BPspec])
go ([Error]
errors, [BPspec]
specs) PState
_ []
      = ([Error] -> [Error]
forall a. [a] -> [a]
reverse [Error]
errors, [BPspec] -> [BPspec]
forall a. [a] -> [a]
reverse [BPspec]
specs)
    go ([Error]
errors, [BPspec]
specs) PState
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 PState
-> Parser [BPspec]
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PState, [BPspec])
forall a.
PState
-> Parser a
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PState, a)
parseWithError PState
pstate (Parser BPspec -> Parser [BPspec]
forall a. Parser a -> Parser [a]
block Parser BPspec
specP) SourcePos
pos [Char]
specComment of
          Left ParseErrorBundle [Char] Void
err'       -> ([Error], [BPspec])
-> PState -> [(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) PState
pstate [(SourcePos, [Char])]
xs
          Right (PState
st,[BPspec]
spec) -> ([Error], [BPspec])
-> PState -> [(SourcePos, [Char])] -> ([Error], [BPspec])
go ([Error]
errors,[BPspec]
spec [BPspec] -> [BPspec] -> [BPspec]
forall a. [a] -> [a] -> [a]
++ [BPspec]
specs) PState
st [(SourcePos, [Char])]
xs

initPStateWithList :: PState
initPStateWithList :: PState
initPStateWithList
  = (Maybe Expr -> PState
initPState Maybe Expr
composeFun)
               { empList    = Just (EVar ("GHC.Types.[]" :: Symbol))
               , singList   = Just (\Expr
e -> Expr -> Expr -> Expr
EApp (Expr -> Expr -> Expr
EApp (Symbol -> Expr
EVar (Symbol
"GHC.Types.:"  :: Symbol)) Expr
e) (Symbol -> Expr
EVar (Symbol
"GHC.Types.[]" :: Symbol)))
               }
  where composeFun :: Maybe Expr
composeFun = Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Expr -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ Symbol -> Expr
EVar Symbol
functionComposisionSymbol

-- | Used to parse .spec files.
specSpecificationP  :: SourceName -> String -> Either (ParseErrorBundle String Void) (ModName, Measure.BareSpec)
--------------------------------------------------------------------------
specSpecificationP :: [Char]
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (ModName, BareSpec)
specSpecificationP [Char]
f [Char]
s = ((PState, (ModName, BareSpec)) -> (ModName, BareSpec))
-> Either
     (ParseErrorBundle [Char] Void) (PState, (ModName, BareSpec))
-> Either (ParseErrorBundle [Char] Void) (ModName, BareSpec)
forall a b l. (a -> b) -> Either l a -> Either l b
mapRight (PState, (ModName, BareSpec)) -> (ModName, BareSpec)
forall a b. (a, b) -> b
snd (Either
   (ParseErrorBundle [Char] Void) (PState, (ModName, BareSpec))
 -> Either (ParseErrorBundle [Char] Void) (ModName, BareSpec))
-> Either
     (ParseErrorBundle [Char] Void) (PState, (ModName, BareSpec))
-> Either (ParseErrorBundle [Char] Void) (ModName, BareSpec)
forall a b. (a -> b) -> a -> b
$  PState
-> Parser (ModName, BareSpec)
-> SourcePos
-> [Char]
-> Either
     (ParseErrorBundle [Char] Void) (PState, (ModName, BareSpec))
forall a.
PState
-> Parser a
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PState, a)
parseWithError PState
initPStateWithList (Parser (ModName, BareSpec)
specificationP Parser (ModName, BareSpec)
-> StateT PState (Parsec Void [Char]) ()
-> Parser (ModName, BareSpec)
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* StateT PState (Parsec Void [Char]) ()
forall e s (m :: * -> *). MonadParsec e s m => m ()
eof) ([Char] -> SourcePos
initialPos [Char]
f) [Char]
s

-- | Parses a module spec.
--
-- A module spec is a module only containing spec constructs for Liquid Haskell,
-- and no "normal" Haskell code.
--
specificationP :: Parser (ModName, Measure.BareSpec)
specificationP :: Parser (ModName, BareSpec)
specificationP = do
  [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"module"
  [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"spec"
  Symbol
name   <- Parser Symbol
symbolP
  [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"where"
  [BPspec]
xs     <- Parser BPspec -> Parser [BPspec]
forall a. Parser a -> Parser [a]
block Parser BPspec
specP
  (ModName, BareSpec) -> Parser (ModName, BareSpec)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ((ModName, BareSpec) -> Parser (ModName, BareSpec))
-> (ModName, BareSpec) -> Parser (ModName, BareSpec)
forall a b. (a -> b) -> a -> b
$ ModName -> [BPspec] -> (ModName, BareSpec)
mkSpec (ModType -> ModuleName -> ModName
ModName ModType
SpecImport (ModuleName -> ModName) -> ModuleName -> ModName
forall a b. (a -> b) -> a -> b
$ [Char] -> ModuleName
mkModuleName ([Char] -> ModuleName) -> [Char] -> ModuleName
forall a b. (a -> b) -> a -> b
$ Symbol -> [Char]
symbolString Symbol
name) [BPspec]
xs

-- debugP = grabs (specP <* whiteSpace)

-------------------------------------------------------------------------------
singleSpecP :: SourcePos -> String -> Either (ParseErrorBundle String Void) BPspec
-------------------------------------------------------------------------------
singleSpecP :: SourcePos -> [Char] -> Either (ParseErrorBundle [Char] Void) BPspec
singleSpecP SourcePos
pos = ((PState, BPspec) -> BPspec)
-> Either (ParseErrorBundle [Char] Void) (PState, BPspec)
-> Either (ParseErrorBundle [Char] Void) BPspec
forall a b l. (a -> b) -> Either l a -> Either l b
mapRight (PState, BPspec) -> BPspec
forall a b. (a, b) -> b
snd (Either (ParseErrorBundle [Char] Void) (PState, BPspec)
 -> Either (ParseErrorBundle [Char] Void) BPspec)
-> ([Char]
    -> Either (ParseErrorBundle [Char] Void) (PState, BPspec))
-> [Char]
-> Either (ParseErrorBundle [Char] Void) BPspec
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PState
-> Parser BPspec
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PState, BPspec)
forall a.
PState
-> Parser a
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PState, a)
parseWithError PState
initPStateWithList Parser 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. PState -> Parser a -> SourcePos -> String -> Either (ParseErrorBundle String Void) (PState, a)
parseWithError :: forall a.
PState
-> Parser a
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PState, a)
parseWithError PState
pstate Parser a
parser SourcePos
p [Char]
s =
  case (State [Char] Void,
 Either (ParseErrorBundle [Char] Void) (a, PState))
-> Either (ParseErrorBundle [Char] Void) (a, PState)
forall a b. (a, b) -> b
snd (Identity
  (State [Char] Void,
   Either (ParseErrorBundle [Char] Void) (a, PState))
-> (State [Char] Void,
    Either (ParseErrorBundle [Char] Void) (a, PState))
forall a. Identity a -> a
runIdentity (ParsecT Void [Char] Identity (a, PState)
-> State [Char] Void
-> Identity
     (State [Char] Void,
      Either (ParseErrorBundle [Char] Void) (a, PState))
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 -> PState -> ParsecT Void [Char] Identity (a, PState)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT Parser a
doParse PState
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) (PState, a)
forall a b. a -> Either a b
Left ParseErrorBundle [Char] Void
peb
    Right (a
r, PState
st) -> (PState, a) -> Either (ParseErrorBundle [Char] Void) (PState, a)
forall a b. b -> Either a b
Right (PState
st, a
r)
  where
    doParse :: Parser a
    doParse :: Parser a
doParse = StateT PState (Parsec Void [Char]) ()
spaces StateT PState (Parsec Void [Char]) () -> Parser a -> Parser a
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser a
parser Parser a -> StateT PState (Parsec Void [Char]) () -> Parser a
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* StateT PState (Parsec Void [Char]) ()
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 -> PState -> Parsec Void [Char] a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT Parser a
parser PState
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)

--------------------------------------------------------------------------------
-- Parse to Logic  -------------------------------------------------------------
--------------------------------------------------------------------------------

parseSymbolToLogic :: SourceName -> String -> Either (ParseErrorBundle String Void) LogicMap
parseSymbolToLogic :: [Char] -> [Char] -> Either (ParseErrorBundle [Char] Void) LogicMap
parseSymbolToLogic [Char]
f = ((PState, LogicMap) -> LogicMap)
-> Either (ParseErrorBundle [Char] Void) (PState, LogicMap)
-> Either (ParseErrorBundle [Char] Void) LogicMap
forall a b l. (a -> b) -> Either l a -> Either l b
mapRight (PState, LogicMap) -> LogicMap
forall a b. (a, b) -> b
snd (Either (ParseErrorBundle [Char] Void) (PState, LogicMap)
 -> Either (ParseErrorBundle [Char] Void) LogicMap)
-> ([Char]
    -> Either (ParseErrorBundle [Char] Void) (PState, LogicMap))
-> [Char]
-> Either (ParseErrorBundle [Char] Void) LogicMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PState
-> Parser LogicMap
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PState, LogicMap)
forall a.
PState
-> Parser a
-> SourcePos
-> [Char]
-> Either (ParseErrorBundle [Char] Void) (PState, a)
parseWithError PState
initPStateWithList Parser LogicMap
toLogicP ([Char] -> SourcePos
initialPos [Char]
f)

toLogicP :: Parser LogicMap
toLogicP :: Parser LogicMap
toLogicP
  = [(LocSymbol, [Symbol], Expr)] -> LogicMap
toLogicMap ([(LocSymbol, [Symbol], Expr)] -> LogicMap)
-> StateT PState (Parsec Void [Char]) [(LocSymbol, [Symbol], Expr)]
-> Parser LogicMap
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (LocSymbol, [Symbol], Expr)
-> StateT PState (Parsec Void [Char]) [(LocSymbol, [Symbol], Expr)]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many StateT PState (Parsec Void [Char]) (LocSymbol, [Symbol], Expr)
toLogicOneP

toLogicOneP :: Parser  (LocSymbol, [Symbol], Expr)
toLogicOneP :: StateT PState (Parsec Void [Char]) (LocSymbol, [Symbol], Expr)
toLogicOneP
  = do [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"define"
       (LocSymbol
x:[LocSymbol]
xs) <- StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) [LocSymbol]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some StateT PState (Parsec Void [Char]) LocSymbol
locSymbolP
       [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"="
       Expr
e      <- Parser Expr
exprP Parser Expr -> Parser Expr -> Parser Expr
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Expr
predP
       (LocSymbol, [Symbol], Expr)
-> StateT PState (Parsec Void [Char]) (LocSymbol, [Symbol], Expr)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (LocSymbol
x, 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, Expr
e)


defineP :: Parser (LocSymbol, Symbol)
defineP :: Parser (LocSymbol, Symbol)
defineP =
  (,) (LocSymbol -> Symbol -> (LocSymbol, Symbol))
-> StateT PState (Parsec Void [Char]) LocSymbol
-> StateT
     PState (Parsec Void [Char]) (Symbol -> (LocSymbol, Symbol))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) LocSymbol
locBinderP StateT PState (Parsec Void [Char]) (Symbol -> (LocSymbol, Symbol))
-> StateT PState (Parsec Void [Char]) ()
-> StateT
     PState (Parsec Void [Char]) (Symbol -> (LocSymbol, Symbol))
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"=" StateT PState (Parsec Void [Char]) (Symbol -> (LocSymbol, Symbol))
-> Parser Symbol -> Parser (LocSymbol, Symbol)
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Symbol
binderP

--------------------------------------------------------------------------------
-- | 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 -> RType BTyCon BTyVar RReft
_pct :: BareType }
                    deriving (Int -> ParamComp -> ShowS
[ParamComp] -> ShowS
ParamComp -> [Char]
(Int -> ParamComp -> ShowS)
-> (ParamComp -> [Char])
-> ([ParamComp] -> ShowS)
-> Show ParamComp
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ParamComp -> ShowS
showsPrec :: Int -> ParamComp -> ShowS
$cshow :: ParamComp -> [Char]
show :: ParamComp -> [Char]
$cshowList :: [ParamComp] -> ShowS
showList :: [ParamComp] -> ShowS
Show)

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 :: BareType -> ParamComp
nullPC :: RType BTyCon BTyVar RReft -> ParamComp
nullPC RType BTyCon BTyVar RReft
bt = PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC PcScope
PcNoSymbol RType BTyCon BTyVar RReft
bt

btP :: Parser ParamComp
btP :: Parser ParamComp
btP = do
  c :: ParamComp
c@(PC PcScope
sb RType BTyCon BTyVar RReft
_) <- Parser ParamComp
compP
  case PcScope
sb of
    PcScope
PcNoSymbol   -> ParamComp -> Parser ParamComp
forall a. a -> StateT PState (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 RType BTyCon BTyVar RReft
t1) Symbol
sym  =
      (do
            [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"->"
            PC PcScope
_ RType BTyCon BTyVar RReft
t2 <- Parser ParamComp
btP
            ParamComp -> Parser ParamComp
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC PcScope
sb (Symbol
-> RType BTyCon BTyVar RReft
-> RType BTyCon BTyVar RReft
-> RType BTyCon BTyVar RReft
forall r c tv.
Monoid r =>
Symbol -> RType c tv r -> RType c tv r -> RType c tv r
rFun Symbol
sym RType BTyCon BTyVar RReft
t1 RType BTyCon BTyVar RReft
t2)))
        Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
         (do
            [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"=>"
            PC PcScope
_ RType BTyCon BTyVar RReft
t2 <- Parser ParamComp
btP
            -- TODO:AZ return an error if s == PcExplicit
            ParamComp -> Parser ParamComp
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamComp -> Parser ParamComp) -> ParamComp -> Parser ParamComp
forall a b. (a -> b) -> a -> b
$ PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC PcScope
sb (RType BTyCon BTyVar RReft -> ParamComp)
-> RType BTyCon BTyVar RReft -> ParamComp
forall a b. (a -> b) -> a -> b
$ (RType BTyCon BTyVar RReft
 -> RType BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft)
-> RType BTyCon BTyVar RReft
-> [RType BTyCon BTyVar RReft]
-> RType BTyCon BTyVar RReft
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Symbol
-> RType BTyCon BTyVar RReft
-> RType BTyCon BTyVar RReft
-> RType BTyCon BTyVar RReft
forall r c tv.
Monoid r =>
Symbol -> RType c tv r -> RType c tv r -> RType c tv r
rFun Symbol
dummySymbol) RType BTyCon BTyVar RReft
t2 (RType BTyCon BTyVar RReft -> [RType BTyCon BTyVar RReft]
forall t t1. RType BTyCon t t1 -> [RType BTyCon t t1]
getClasses RType BTyCon BTyVar RReft
t1))
         Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
          (do
             LocSymbol
b <- StateT PState (Parsec Void [Char]) LocSymbol
locInfixSymbolP
             PC PcScope
_ RType BTyCon BTyVar RReft
t2 <- Parser ParamComp
btP
             ParamComp -> Parser ParamComp
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamComp -> Parser ParamComp) -> ParamComp -> Parser ParamComp
forall a b. (a -> b) -> a -> b
$ PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC PcScope
sb (RType BTyCon BTyVar RReft -> ParamComp)
-> RType BTyCon BTyVar RReft -> ParamComp
forall a b. (a -> b) -> a -> b
$ BTyCon
-> [RType BTyCon BTyVar RReft]
-> [RTProp BTyCon BTyVar RReft]
-> RReft
-> RType BTyCon BTyVar RReft
forall c tv r.
c -> [RType c tv r] -> [RTProp c tv r] -> r -> RType c tv r
RApp (LocSymbol -> BTyCon
mkBTyCon LocSymbol
b) [RType BTyCon BTyVar RReft
t1,RType BTyCon BTyVar RReft
t2] [] RReft
forall a. Monoid a => a
mempty)
         Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParamComp -> Parser ParamComp
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ParamComp
c


compP :: Parser ParamComp
compP :: Parser ParamComp
compP = Parser ParamComp
circleP Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParamComp -> Parser ParamComp
forall a. Parser a -> Parser 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
  =  RType BTyCon BTyVar RReft -> ParamComp
nullPC (RType BTyCon BTyVar RReft -> ParamComp)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> Parser ParamComp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"forall" StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareAllP)
 Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (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 PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (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 PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (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 PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (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 PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (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 PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RType BTyCon BTyVar RReft -> ParamComp
nullPC (RType BTyCon BTyVar RReft -> ParamComp)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> Parser ParamComp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (m :: * -> *) b. Monad m => m (Reft -> b) -> m b
dummyP StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
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 a. Parser a -> Parser a
angles (Parser ParamComp -> Parser ParamComp)
-> Parser ParamComp -> Parser ParamComp
forall a b. (a -> b) -> a -> b
$ do
      PC PcScope
sb RType BTyCon BTyVar RReft
t <- Parser ParamComp -> Parser ParamComp
forall a. Parser a -> Parser a
parens Parser ParamComp
btP
      Predicate
p       <- Parser Predicate
monoPredicateP
      ParamComp -> Parser ParamComp
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return   (ParamComp -> Parser ParamComp) -> ParamComp -> Parser ParamComp
forall a b. (a -> b) -> a -> b
$ PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC PcScope
sb (RType BTyCon BTyVar RReft
t RType BTyCon BTyVar RReft -> RReft -> RType BTyCon BTyVar RReft
forall r c tv. Reftable r => RType c tv r -> r -> RType c tv r
`strengthen` Reft -> Predicate -> RReft
forall r. r -> Predicate -> UReft r
MkUReft Reft
forall a. Monoid a => a
mempty Predicate
p)

holePC :: Parser ParamComp
holePC :: Parser ParamComp
holePC = do
  RType BTyCon BTyVar RReft
h <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
holeP
  Symbol
b <- Parser Symbol
dummyBindP
  ParamComp -> Parser ParamComp
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC (Symbol -> PcScope
PcImplicit Symbol
b) RType BTyCon BTyVar RReft
h)

namedCircleP :: Parser ParamComp
namedCircleP :: Parser ParamComp
namedCircleP = do
  LocSymbol
lb <- StateT PState (Parsec Void [Char]) LocSymbol
locLowerIdP
  do ()
_ <- [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
":"
     let b :: Symbol
b = LocSymbol -> Symbol
forall a. Located a -> a
val LocSymbol
lb
     PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC (Symbol -> PcScope
PcExplicit Symbol
b) (RType BTyCon BTyVar RReft -> ParamComp)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> Parser ParamComp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Symbol
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareArgP Symbol
b
    Parser ParamComp -> Parser ParamComp -> Parser ParamComp
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> do
      Symbol
b <- Parser Symbol
dummyBindP
      PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC (Symbol -> PcScope
PcImplicit Symbol
b) (RType BTyCon BTyVar RReft -> ParamComp)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> Parser ParamComp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (m :: * -> *) b. Monad m => m (Reft -> b) -> m b
dummyP (Symbol
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
lowerIdTail (LocSymbol -> Symbol
forall a. Located a -> a
val LocSymbol
lb))

unnamedCircleP :: Parser ParamComp
unnamedCircleP :: Parser ParamComp
unnamedCircleP = do
  LocSymbol
lb <- Parser Symbol -> StateT PState (Parsec Void [Char]) LocSymbol
forall a. Parser a -> Parser (Located a)
located Parser Symbol
dummyBindP
  let b :: Symbol
b = LocSymbol -> Symbol
forall a. Located a -> a
val LocSymbol
lb
  RType BTyCon BTyVar RReft
t1 <- Symbol
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareArgP Symbol
b
  ParamComp -> Parser ParamComp
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamComp -> Parser ParamComp) -> ParamComp -> Parser ParamComp
forall a b. (a -> b) -> a -> b
$ PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC (Symbol -> PcScope
PcImplicit Symbol
b) RType BTyCon BTyVar RReft
t1

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

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

bareTypeP :: Parser BareType
bareTypeP :: StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP = do
  PC PcScope
_ RType BTyCon BTyVar RReft
v <- Parser ParamComp
btP
  RType BTyCon BTyVar RReft
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return RType BTyCon BTyVar RReft
v

bareTypeBracesP :: Parser ParamComp
bareTypeBracesP :: Parser ParamComp
bareTypeBracesP = do
  Either ParamComp (RType BTyCon BTyVar RReft)
t <-  StateT
  PState
  (Parsec Void [Char])
  (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (StateT
  PState
  (Parsec Void [Char])
  (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
braces (
            StateT
  PState
  (Parsec Void [Char])
  (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (RType BTyCon BTyVar RReft
-> Either ParamComp (RType BTyCon BTyVar RReft)
forall a b. b -> Either a b
Right (RType BTyCon BTyVar RReft
 -> Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
constraintP)
           StateT
  PState
  (Parsec Void [Char])
  (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
            (do
                    Symbol
x  <- Parser Symbol
symbolP
                    ()
_ <- [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
":"
                    -- NOSUBST i  <- freshIntP
                    Reft -> RType BTyCon BTyVar RReft
t  <- StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseP
                    [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"|"
                    Expr
ra <- Parser Expr
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
                    Either ParamComp (RType BTyCon BTyVar RReft)
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either ParamComp (RType BTyCon BTyVar RReft)
 -> StateT
      PState
      (Parsec Void [Char])
      (Either ParamComp (RType BTyCon BTyVar RReft)))
-> Either ParamComp (RType BTyCon BTyVar RReft)
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall a b. (a -> b) -> a -> b
$ ParamComp -> Either ParamComp (RType BTyCon BTyVar RReft)
forall a b. a -> Either a b
Left (ParamComp -> Either ParamComp (RType BTyCon BTyVar RReft))
-> ParamComp -> Either ParamComp (RType BTyCon BTyVar RReft)
forall a b. (a -> b) -> a -> b
$ PcScope -> RType BTyCon BTyVar RReft -> ParamComp
PC (Symbol -> PcScope
PcExplicit Symbol
x) (RType BTyCon BTyVar RReft -> ParamComp)
-> RType BTyCon BTyVar RReft -> ParamComp
forall a b. (a -> b) -> a -> b
$ Reft -> RType BTyCon BTyVar RReft
t ((Symbol, Expr) -> Reft
Reft (Symbol
x, Expr
ra)) )
            )) StateT
  PState
  (Parsec Void [Char])
  (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  PState
  (Parsec Void [Char])
  (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser Expr
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall {b}. Parser Expr -> Parser (Either ParamComp b)
helper Parser Expr
holeOrPredsP) StateT
  PState
  (Parsec Void [Char])
  (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Expr
-> StateT
     PState
     (Parsec Void [Char])
     (Either ParamComp (RType BTyCon BTyVar RReft))
forall {b}. Parser Expr -> Parser (Either ParamComp b)
helper Parser Expr
predP
  case Either ParamComp (RType BTyCon BTyVar RReft)
t of
    Left ParamComp
l -> ParamComp -> Parser ParamComp
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ParamComp
l
    Right RType BTyCon BTyVar RReft
ct -> do
      PC PcScope
_sb RType BTyCon BTyVar RReft
tt <- Parser ParamComp
btP
      ParamComp -> Parser ParamComp
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamComp -> Parser ParamComp) -> ParamComp -> Parser ParamComp
forall a b. (a -> b) -> a -> b
$ RType BTyCon BTyVar RReft -> ParamComp
nullPC (RType BTyCon BTyVar RReft -> ParamComp)
-> RType BTyCon BTyVar RReft -> ParamComp
forall a b. (a -> b) -> a -> b
$ RType BTyCon BTyVar RReft
-> RType BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft
forall r c tv.
Monoid r =>
RType c tv r -> RType c tv r -> RType c tv r
rrTy RType BTyCon BTyVar RReft
ct RType BTyCon BTyVar RReft
tt
  where
    holeOrPredsP :: Parser Expr
holeOrPredsP
      = ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"_" StateT PState (Parsec Void [Char]) () -> Parser Expr -> Parser Expr
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Expr -> Parser Expr
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Expr
hole)
     Parser Expr -> Parser Expr -> Parser Expr
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (ListNE Expr -> Expr
pAnd (ListNE Expr -> Expr)
-> StateT PState (Parsec Void [Char]) (ListNE Expr) -> Parser Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (ListNE Expr)
-> StateT PState (Parsec Void [Char]) (ListNE Expr)
forall a. Parser a -> Parser a
brackets (Parser Expr
-> StateT PState (Parsec Void [Char]) [Char]
-> StateT PState (Parsec Void [Char]) (ListNE Expr)
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy Parser Expr
predP StateT PState (Parsec Void [Char]) [Char]
semi))
    helper :: Parser Expr -> Parser (Either ParamComp b)
helper Parser Expr
p = Parser (Either ParamComp b) -> Parser (Either ParamComp b)
forall a. Parser a -> Parser a
braces (Parser (Either ParamComp b) -> Parser (Either ParamComp b))
-> Parser (Either ParamComp b) -> Parser (Either ParamComp b)
forall a b. (a -> b) -> a -> b
$ do
      RType BTyCon BTyVar RReft
t <- RReft -> RType BTyCon BTyVar RReft
forall c tv r. r -> RType c tv r
RHole (RReft -> RType BTyCon BTyVar RReft)
-> (Expr -> RReft) -> Expr -> RType BTyCon BTyVar RReft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reft -> RReft
forall r. r -> UReft r
uTop (Reft -> RReft) -> (Expr -> Reft) -> Expr -> RReft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Symbol, Expr) -> Reft
Reft ((Symbol, Expr) -> Reft)
-> (Expr -> (Symbol, Expr)) -> Expr -> Reft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Symbol
"VV",) (Expr -> RType BTyCon BTyVar RReft)
-> Parser Expr
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
p
      Either ParamComp b -> Parser (Either ParamComp b)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamComp -> Either ParamComp b
forall a b. a -> Either a b
Left (ParamComp -> Either ParamComp b)
-> ParamComp -> Either ParamComp b
forall a b. (a -> b) -> a -> b
$ RType BTyCon BTyVar RReft -> ParamComp
nullPC RType BTyCon BTyVar RReft
t)


bareArgP :: Symbol -> Parser BareType
bareArgP :: Symbol
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareArgP Symbol
vvv
  =  Symbol
-> Parser Expr
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
refDefP Symbol
vvv Parser Expr
refasHoleP StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseP    -- starts with '{'
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
holeP                            -- starts with '_'
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (m :: * -> *) b. Monad m => m (Reft -> b) -> m b
dummyP StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseP
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
parens StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP                 -- starts with '('
                                      -- starts with '_', '[', '(', lower, upper
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> [Char]
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bareArgP"

bareAtomP :: (Parser Expr -> Parser (Reft -> BareType) -> Parser BareType)
          -> Parser BareType
bareAtomP :: (Parser Expr
 -> StateT
      PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
 -> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareAtomP Parser Expr
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
ref
  =  Parser Expr
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
ref Parser Expr
refasHoleP StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseP
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
holeP
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (m :: * -> *) b. Monad m => m (Reft -> b) -> m b
dummyP StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseP
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> [Char]
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bareAtomP"

bareAtomBindP :: Parser BareType
bareAtomBindP :: StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareAtomBindP = (Parser Expr
 -> StateT
      PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
 -> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareAtomP Parser Expr
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
refBindBindP


-- Either
--  { x : t | ra }
-- or
--  { ra }
refBindBindP :: Parser Expr
             -> Parser (Reft -> BareType)
             -> Parser BareType
refBindBindP :: Parser Expr
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
refBindBindP Parser Expr
rp StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
kindP'
  = StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
braces (
      (do
              Symbol
x  <- Parser Symbol
symbolP
              ()
_ <- [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
":"
              -- NOSUBST i  <- freshIntP
              Reft -> RType BTyCon BTyVar RReft
t  <- StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
kindP'
              [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"|"
              Expr
ra <- Parser Expr
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
              RType BTyCon BTyVar RReft
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RType BTyCon BTyVar RReft
 -> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft))
-> RType BTyCon BTyVar RReft
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a b. (a -> b) -> a -> b
$ {- substa su $ NOSUBST -} Reft -> RType BTyCon BTyVar RReft
t ((Symbol, Expr) -> Reft
Reft (Symbol
x, Expr
ra)) )
     StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (RReft -> RType BTyCon BTyVar RReft
forall c tv r. r -> RType c tv r
RHole (RReft -> RType BTyCon BTyVar RReft)
-> (Expr -> RReft) -> Expr -> RType BTyCon BTyVar RReft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reft -> RReft
forall r. r -> UReft r
uTop (Reft -> RReft) -> (Expr -> Reft) -> Expr -> RReft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Symbol, Expr) -> Reft
Reft ((Symbol, Expr) -> Reft)
-> (Expr -> (Symbol, Expr)) -> Expr -> Reft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Symbol
"VV",) (Expr -> RType BTyCon BTyVar RReft)
-> Parser Expr
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
rp)
     StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> [Char]
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"refBindBindP"
   )


refDefP :: Symbol
        -> Parser Expr
        -> Parser (Reft -> BareType)
        -> Parser BareType
refDefP :: Symbol
-> Parser Expr
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
refDefP Symbol
sym Parser Expr
rp StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
kindP' = StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
braces (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
 -> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a b. (a -> b) -> a -> b
$ do
  Symbol
x       <- Symbol -> Parser Symbol
optBindP Symbol
sym
  -- NOSUBST i       <- freshIntP
  Reft -> RType BTyCon BTyVar RReft
t       <- StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
kindP' StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) ()
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"|") StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RReft -> RType BTyCon BTyVar RReft
forall c tv r. r -> RType c tv r
RHole (RReft -> RType BTyCon BTyVar RReft)
-> (Reft -> RReft) -> Reft -> RType BTyCon BTyVar RReft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reft -> RReft
forall r. r -> UReft r
uTop) StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> [Char]
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"refDefP"
  Expr
ra      <- Parser Expr
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
  RType BTyCon BTyVar RReft
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return   (RType BTyCon BTyVar RReft
 -> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft))
-> RType BTyCon BTyVar RReft
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a b. (a -> b) -> a -> b
$ {- substa su $ NOSUBST -} Reft -> RType BTyCon BTyVar RReft
t ((Symbol, Expr) -> Reft
Reft (Symbol
x, Expr
ra))
       -- substa su . t . Reft . (x,) <$> (rp <* spaces))
      --  <|> ((RHole . uTop . Reft . ("VV",)) <$> (rp <* spaces))

refP :: Parser (Reft -> BareType) -> Parser BareType
refP :: StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
refP = Parser Expr
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
refBindBindP Parser Expr
refaP

relrefaP :: Parser RelExpr
relrefaP :: Parser RelExpr
relrefaP =
  Parser RelExpr -> Parser RelExpr
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Expr -> RelExpr -> RelExpr
ERUnChecked (Expr -> RelExpr -> RelExpr)
-> Parser Expr
-> StateT PState (Parsec Void [Char]) (RelExpr -> RelExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
refaP StateT PState (Parsec Void [Char]) (RelExpr -> RelExpr)
-> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) (RelExpr -> RelExpr)
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
":=>" StateT PState (Parsec Void [Char]) (RelExpr -> RelExpr)
-> Parser RelExpr -> Parser RelExpr
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RelExpr
relrefaP)
    Parser RelExpr -> Parser RelExpr -> Parser RelExpr
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser RelExpr -> Parser RelExpr
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Expr -> RelExpr -> RelExpr
ERChecked (Expr -> RelExpr -> RelExpr)
-> Parser Expr
-> StateT PState (Parsec Void [Char]) (RelExpr -> RelExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
refaP StateT PState (Parsec Void [Char]) (RelExpr -> RelExpr)
-> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) (RelExpr -> RelExpr)
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"!=>" StateT PState (Parsec Void [Char]) (RelExpr -> RelExpr)
-> Parser RelExpr -> Parser RelExpr
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser RelExpr
relrefaP)
    Parser RelExpr -> Parser RelExpr -> Parser RelExpr
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Expr -> RelExpr
ERBasic (Expr -> RelExpr) -> Parser Expr -> Parser RelExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
refaP

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

holeP :: Parser BareType
holeP :: StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
holeP    = [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"_" StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> RType BTyCon BTyVar RReft
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RReft -> RType BTyCon BTyVar RReft
forall c tv r. r -> RType c tv r
RHole (RReft -> RType BTyCon BTyVar RReft)
-> RReft -> RType BTyCon BTyVar RReft
forall a b. (a -> b) -> a -> b
$ Reft -> RReft
forall r. r -> UReft r
uTop (Reft -> RReft) -> Reft -> RReft
forall a b. (a -> b) -> a -> b
$ (Symbol, Expr) -> Reft
Reft (Symbol
"VV", Expr
hole))

holeRefP :: Parser (Reft -> BareType)
holeRefP :: StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
holeRefP = [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"_" StateT PState (Parsec Void [Char]) ()
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RReft -> RType BTyCon BTyVar RReft
forall c tv r. r -> RType c tv r
RHole (RReft -> RType BTyCon BTyVar RReft)
-> (Reft -> RReft) -> Reft -> RType BTyCon BTyVar RReft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Reft -> RReft
forall r. r -> UReft r
uTop)

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

refasHoleP :: Parser Expr
refasHoleP :: Parser Expr
refasHoleP
  =  ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"_" StateT PState (Parsec Void [Char]) () -> Parser Expr -> Parser Expr
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Expr -> Parser Expr
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Expr
hole)
 Parser Expr -> Parser Expr -> Parser Expr
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Expr
refaP
 Parser Expr -> [Char] -> Parser Expr
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"refasHoleP"

bbaseP :: Parser (Reft -> BareType)
bbaseP :: StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseP
  =  StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
holeRefP  -- Starts with '_'
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Maybe (RType BTyCon BTyVar RReft)
 -> [RTProp BTyCon BTyVar RReft]
 -> Reft
 -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Maybe (RType BTyCon BTyVar RReft)
-> [RTProp BTyCon BTyVar RReft]
-> Reft
-> RType BTyCon BTyVar RReft
forall tv r.
Maybe (RType BTyCon tv (UReft r))
-> [RTProp BTyCon tv (UReft r)] -> r -> RType BTyCon tv (UReft r)
bLst (StateT
  PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
-> StateT
     PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
brackets (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP)) StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
forall tv r c.
(IsString tv, Monoid r) =>
Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
predicatesP
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([(Maybe Symbol, RType BTyCon BTyVar RReft)]
 -> [RTProp BTyCon BTyVar RReft]
 -> Reft
 -> RType BTyCon BTyVar RReft)
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
-> StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 [(Maybe Symbol, RType BTyCon BTyVar RReft)]
-> [RTProp BTyCon BTyVar RReft]
-> Reft
-> RType BTyCon BTyVar RReft
forall r.
(PPrint r, Reftable r, Reftable (RType BTyCon BTyVar (UReft r)),
 Reftable (RTProp BTyCon BTyVar (UReft r))) =>
[(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
-> [RTProp BTyCon BTyVar (UReft r)]
-> r
-> RType BTyCon BTyVar (UReft r)
bTup (StateT
  PState
  (Parsec Void [Char])
  [(Maybe Symbol, RType BTyCon BTyVar RReft)]
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
forall a. Parser a -> Parser a
parens (StateT
   PState
   (Parsec Void [Char])
   [(Maybe Symbol, RType BTyCon BTyVar RReft)]
 -> StateT
      PState
      (Parsec Void [Char])
      [(Maybe Symbol, RType BTyCon BTyVar RReft)])
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
forall a b. (a -> b) -> a -> b
$ StateT
  PState
  (Parsec Void [Char])
  (Maybe Symbol, RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) [Char]
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState
     (Parsec Void [Char])
     (Maybe Symbol, RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser (Maybe Symbol, a)
maybeBind StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP) StateT PState (Parsec Void [Char]) [Char]
comma) StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
forall tv r c.
(IsString tv, Monoid r) =>
Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
predicatesP
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
parseHelper  -- starts with lower
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (BTyCon
 -> [RTProp BTyCon BTyVar RReft]
 -> [RType BTyCon BTyVar RReft]
 -> Predicate
 -> Reft
 -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) BTyCon
-> StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
-> StateT PState (Parsec Void [Char]) [RType BTyCon BTyVar RReft]
-> Parser Predicate
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
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
-> [RTProp BTyCon BTyVar RReft]
-> [RType BTyCon BTyVar RReft]
-> Predicate
-> Reft
-> RType BTyCon BTyVar RReft
forall c tv r.
c
-> [RTProp c tv (UReft r)]
-> [RType c tv (UReft r)]
-> Predicate
-> r
-> RType c tv (UReft r)
bCon StateT PState (Parsec Void [Char]) BTyCon
bTyConP StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
forall tv r c.
(IsString tv, Monoid r) =>
Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
predicatesP (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) [RType BTyCon BTyVar RReft]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTyArgP) Parser Predicate
mmonoPredicateP
           -- starts with "'" or upper case char
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> [Char]
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bbaseP"
 where
   parseHelper :: StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
parseHelper = do
     Symbol
l <- Parser Symbol
lowerIdP
     Symbol
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
lowerIdTail Symbol
l

maybeBind :: Parser a -> Parser (Maybe Symbol, a)
maybeBind :: forall a. Parser a -> Parser (Maybe Symbol, a)
maybeBind Parser a
parser = do {Maybe Symbol
bd <- Parser Symbol -> StateT PState (Parsec Void [Char]) (Maybe Symbol)
forall {f :: * -> *} {e} {s} {a}.
MonadParsec e s f =>
f a -> f (Maybe a)
maybeP' Parser Symbol
bbindP; a
ty <- Parser a
parser ; (Maybe Symbol, a) -> Parser (Maybe Symbol, a)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Symbol
bd, a
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 :: Symbol -> Parser (Reft -> BareType)
lowerIdTail :: Symbol
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
lowerIdTail Symbol
l =
          ([RType BTyCon BTyVar RReft] -> Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) [RType BTyCon BTyVar RReft]
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (BTyVar
-> [RType BTyCon BTyVar RReft] -> Reft -> RType BTyCon BTyVar RReft
forall (t :: * -> *) r tv c.
(Foldable t, PPrint r, Reftable r) =>
tv -> t (RType c tv (UReft r)) -> r -> RType c tv (UReft r)
bAppTy (Symbol -> BTyVar
bTyVar Symbol
l)) (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) [RType BTyCon BTyVar RReft]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTyArgP)
      StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Predicate -> Reft -> RType BTyCon BTyVar RReft)
-> Parser Predicate
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (BTyVar -> Predicate -> Reft -> RType BTyCon BTyVar RReft
forall tv r c. tv -> Predicate -> r -> RType c tv (UReft r)
bRVar (Symbol -> BTyVar
bTyVar Symbol
l)) Parser Predicate
monoPredicateP

bTyConP :: Parser BTyCon
bTyConP :: StateT PState (Parsec Void [Char]) BTyCon
bTyConP
  =  ([Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"'" StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) BTyCon
-> StateT PState (Parsec Void [Char]) BTyCon
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (LocSymbol -> BTyCon
mkPromotedBTyCon (LocSymbol -> BTyCon)
-> StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) BTyCon
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) LocSymbol
locUpperIdP))
 StateT PState (Parsec Void [Char]) BTyCon
-> StateT PState (Parsec Void [Char]) BTyCon
-> StateT PState (Parsec Void [Char]) BTyCon
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> LocSymbol -> BTyCon
mkBTyCon (LocSymbol -> BTyCon)
-> StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) BTyCon
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) LocSymbol
locUpperIdP
 StateT PState (Parsec Void [Char]) BTyCon
-> StateT PState (Parsec Void [Char]) BTyCon
-> StateT PState (Parsec Void [Char]) BTyCon
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"*" StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) BTyCon
-> StateT PState (Parsec Void [Char]) BTyCon
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BTyCon -> StateT PState (Parsec Void [Char]) BTyCon
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (LocSymbol -> BTyCon
mkBTyCon (Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc (Symbol -> LocSymbol) -> Symbol -> LocSymbol
forall a b. (a -> b) -> a -> b
$ [Char] -> Symbol
forall a. Symbolic a => a -> Symbol
symbol ([Char]
"*" :: String))))
 StateT PState (Parsec Void [Char]) BTyCon
-> [Char] -> StateT PState (Parsec Void [Char]) BTyCon
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bTyConP"

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

classBTyConP :: Parser BTyCon
classBTyConP :: StateT PState (Parsec Void [Char]) BTyCon
classBTyConP = LocSymbol -> BTyCon
mkClassBTyCon (LocSymbol -> BTyCon)
-> StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) BTyCon
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) LocSymbol
locUpperIdP

mkClassBTyCon :: LocSymbol -> BTyCon
mkClassBTyCon :: LocSymbol -> BTyCon
mkClassBTyCon LocSymbol
x = LocSymbol -> Bool -> Bool -> BTyCon
BTyCon LocSymbol
x Bool
True Bool
False

bbaseNoAppP :: Parser (Reft -> BareType)
bbaseNoAppP :: StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseNoAppP
  =  StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
holeRefP
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Maybe (RType BTyCon BTyVar RReft)
 -> [RTProp BTyCon BTyVar RReft]
 -> Reft
 -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Maybe (RType BTyCon BTyVar RReft)
-> [RTProp BTyCon BTyVar RReft]
-> Reft
-> RType BTyCon BTyVar RReft
forall tv r.
Maybe (RType BTyCon tv (UReft r))
-> [RTProp BTyCon tv (UReft r)] -> r -> RType BTyCon tv (UReft r)
bLst (StateT
  PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
-> StateT
     PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
brackets (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP)) StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
forall tv r c.
(IsString tv, Monoid r) =>
Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
predicatesP
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([(Maybe Symbol, RType BTyCon BTyVar RReft)]
 -> [RTProp BTyCon BTyVar RReft]
 -> Reft
 -> RType BTyCon BTyVar RReft)
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
-> StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 [(Maybe Symbol, RType BTyCon BTyVar RReft)]
-> [RTProp BTyCon BTyVar RReft]
-> Reft
-> RType BTyCon BTyVar RReft
forall r.
(PPrint r, Reftable r, Reftable (RType BTyCon BTyVar (UReft r)),
 Reftable (RTProp BTyCon BTyVar (UReft r))) =>
[(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
-> [RTProp BTyCon BTyVar (UReft r)]
-> r
-> RType BTyCon BTyVar (UReft r)
bTup (StateT
  PState
  (Parsec Void [Char])
  [(Maybe Symbol, RType BTyCon BTyVar RReft)]
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
forall a. Parser a -> Parser a
parens (StateT
   PState
   (Parsec Void [Char])
   [(Maybe Symbol, RType BTyCon BTyVar RReft)]
 -> StateT
      PState
      (Parsec Void [Char])
      [(Maybe Symbol, RType BTyCon BTyVar RReft)])
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
forall a b. (a -> b) -> a -> b
$ StateT
  PState
  (Parsec Void [Char])
  (Maybe Symbol, RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) [Char]
-> StateT
     PState
     (Parsec Void [Char])
     [(Maybe Symbol, RType BTyCon BTyVar RReft)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState
     (Parsec Void [Char])
     (Maybe Symbol, RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser (Maybe Symbol, a)
maybeBind StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP) StateT PState (Parsec Void [Char]) [Char]
comma) StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
forall tv r c.
(IsString tv, Monoid r) =>
Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
predicatesP
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ((BTyCon
 -> [RTProp BTyCon BTyVar RReft]
 -> [RType BTyCon BTyVar RReft]
 -> Predicate
 -> Reft
 -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) BTyCon
-> StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
-> StateT PState (Parsec Void [Char]) [RType BTyCon BTyVar RReft]
-> Parser Predicate
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
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
-> [RTProp BTyCon BTyVar RReft]
-> [RType BTyCon BTyVar RReft]
-> Predicate
-> Reft
-> RType BTyCon BTyVar RReft
forall c tv r.
c
-> [RTProp c tv (UReft r)]
-> [RType c tv (UReft r)]
-> Predicate
-> r
-> RType c tv (UReft r)
bCon StateT PState (Parsec Void [Char]) BTyCon
bTyConP StateT PState (Parsec Void [Char]) [RTProp BTyCon BTyVar RReft]
forall tv r c.
(IsString tv, Monoid r) =>
Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
predicatesP ([RType BTyCon BTyVar RReft]
-> StateT PState (Parsec Void [Char]) [RType BTyCon BTyVar RReft]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []) (Predicate -> Parser Predicate
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Predicate
forall a. Monoid a => a
mempty))
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (BTyVar -> Predicate -> Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) BTyVar
-> Parser Predicate
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 BTyVar -> Predicate -> Reft -> RType BTyCon BTyVar RReft
forall tv r c. tv -> Predicate -> r -> RType c tv (UReft r)
bRVar (Symbol -> BTyVar
bTyVar (Symbol -> BTyVar)
-> Parser Symbol -> StateT PState (Parsec Void [Char]) BTyVar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
lowerIdP) Parser Predicate
monoPredicateP
 StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> [Char]
-> StateT
     PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bbaseNoAppP"

bareTyArgP :: Parser BareType
bareTyArgP :: StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTyArgP
  =  (Located Expr -> RType BTyCon BTyVar RReft
forall c tv r. Located Expr -> RType c tv r
RExprArg (Located Expr -> RType BTyCon BTyVar RReft)
-> (Located Integer -> Located Expr)
-> Located Integer
-> RType BTyCon BTyVar RReft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Integer -> Expr) -> Located Integer -> Located Expr
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> Expr
forall a. Expression a => a -> Expr
expr (Located Integer -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (Located Integer)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (Located Integer)
locNatural)
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
braces (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
 -> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a b. (a -> b) -> a -> b
$ Located Expr -> RType BTyCon BTyVar RReft
forall c tv r. Located Expr -> RType c tv r
RExprArg (Located Expr -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (Located Expr)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr -> StateT PState (Parsec Void [Char]) (Located Expr)
forall a. Parser a -> Parser (Located a)
located Parser Expr
exprP)
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareAtomNoAppP
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. Parser a -> Parser a
parens StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP)
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> [Char]
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bareTyArgP"

bareAtomNoAppP :: Parser BareType
bareAtomNoAppP :: StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareAtomNoAppP
  =  StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
refP StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseNoAppP
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (m :: * -> *) b. Monad m => m (Reft -> b) -> m b
dummyP StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseNoAppP
 StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> [Char]
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bareAtomNoAppP"


constraintP :: Parser BareType
constraintP :: StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
constraintP
  = do [(LocSymbol, RType BTyCon BTyVar RReft)]
xts <- Parser [(LocSymbol, RType BTyCon BTyVar RReft)]
constraintEnvP
       RType BTyCon BTyVar RReft
t1  <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP
       [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"<:"
       RTypeRep BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft
forall c tv r. RTypeRep c tv r -> RType c tv r
fromRTypeRep (RTypeRep BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft)
-> (RType BTyCon BTyVar RReft -> RTypeRep BTyCon BTyVar RReft)
-> RType BTyCon BTyVar RReft
-> RType BTyCon BTyVar RReft
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(RTVar BTyVar (RType BTyCon BTyVar ()), RReft)]
-> [PVar (RType BTyCon BTyVar ())]
-> [Symbol]
-> [RFInfo]
-> [RReft]
-> [RType BTyCon BTyVar RReft]
-> RType BTyCon BTyVar RReft
-> RTypeRep BTyCon BTyVar RReft
forall c tv r.
[(RTVar tv (RType c tv ()), r)]
-> [PVar (RType c tv ())]
-> [Symbol]
-> [RFInfo]
-> [r]
-> [RType c tv r]
-> RType c tv r
-> RTypeRep c tv r
RTypeRep [] []
                               ((LocSymbol -> Symbol
forall a. Located a -> a
val (LocSymbol -> Symbol)
-> ((LocSymbol, RType BTyCon BTyVar RReft) -> LocSymbol)
-> (LocSymbol, RType BTyCon BTyVar RReft)
-> Symbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LocSymbol, RType BTyCon BTyVar RReft) -> LocSymbol
forall a b. (a, b) -> a
fst ((LocSymbol, RType BTyCon BTyVar RReft) -> Symbol)
-> [(LocSymbol, RType BTyCon BTyVar RReft)] -> [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(LocSymbol, RType BTyCon BTyVar RReft)]
xts) [Symbol] -> [Symbol] -> [Symbol]
forall a. [a] -> [a] -> [a]
++ [Symbol
dummySymbol])
                               (Int -> RFInfo -> [RFInfo]
forall a. Int -> a -> [a]
replicate ([(LocSymbol, RType BTyCon BTyVar RReft)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(LocSymbol, RType BTyCon BTyVar RReft)]
xts Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) RFInfo
defRFInfo)
                               (Int -> RReft -> [RReft]
forall a. Int -> a -> [a]
replicate ([(LocSymbol, RType BTyCon BTyVar RReft)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(LocSymbol, RType BTyCon BTyVar RReft)]
xts Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) RReft
forall a. Monoid a => a
mempty)
                               (((LocSymbol, RType BTyCon BTyVar RReft) -> RType BTyCon BTyVar RReft
forall a b. (a, b) -> b
snd ((LocSymbol, RType BTyCon BTyVar RReft)
 -> RType BTyCon BTyVar RReft)
-> [(LocSymbol, RType BTyCon BTyVar RReft)]
-> [RType BTyCon BTyVar RReft]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(LocSymbol, RType BTyCon BTyVar RReft)]
xts) [RType BTyCon BTyVar RReft]
-> [RType BTyCon BTyVar RReft] -> [RType BTyCon BTyVar RReft]
forall a. [a] -> [a] -> [a]
++ [RType BTyCon BTyVar RReft
t1]) (RType BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP

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

rrTy :: Monoid r => RType c tv r -> RType c tv r -> RType c tv r
rrTy :: forall r c tv.
Monoid r =>
RType c tv r -> RType c tv r -> RType c tv r
rrTy RType c tv r
ct = [(Symbol, RType c tv r)]
-> r -> Oblig -> RType c tv r -> RType c tv r
forall c tv r.
[(Symbol, RType c tv r)]
-> r -> Oblig -> RType c tv r -> RType c tv r
RRTy ([(Symbol, RType c tv r)]
xts [(Symbol, RType c tv r)]
-> [(Symbol, RType c tv r)] -> [(Symbol, RType c tv r)]
forall a. [a] -> [a] -> [a]
++ [(Symbol
dummySymbol, RType c tv r
tr)]) r
forall a. Monoid a => a
mempty Oblig
OCons
  where
    tr :: RType c tv r
tr   = RTypeRep c tv r -> RType c tv r
forall c tv r. RTypeRep c tv r -> RType c tv r
ty_res RTypeRep c tv r
trep
    xts :: [(Symbol, RType c tv r)]
xts  = [Symbol] -> [RType c tv r] -> [(Symbol, RType c tv r)]
forall a b. [a] -> [b] -> [(a, b)]
zip (RTypeRep c tv r -> [Symbol]
forall c tv r. RTypeRep c tv r -> [Symbol]
ty_binds RTypeRep c tv r
trep) (RTypeRep c tv r -> [RType c tv r]
forall c tv r. RTypeRep c tv r -> [RType c tv r]
ty_args RTypeRep c tv r
trep)
    trep :: RTypeRep c tv r
trep = RType c tv r -> RTypeRep c tv r
forall c tv r. RType c tv r -> RTypeRep c tv r
toRTypeRep RType c tv r
ct

--  "forall <z w> . TYPE"
-- or
--  "forall x y <z :: Nat, w :: Int> . TYPE"
bareAllP :: Parser BareType
bareAllP :: StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareAllP = do
  SourcePos
sp <- StateT PState (Parsec Void [Char]) SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
  [BTyVar]
as  <- Parser [BTyVar]
tyVarDefsP
  [PVar (RType BTyCon BTyVar ())]
ps  <- Parser [PVar (RType BTyCon BTyVar ())]
-> Parser [PVar (RType BTyCon BTyVar ())]
forall a. Parser a -> Parser a
angles Parser [PVar (RType BTyCon BTyVar ())]
inAngles
        Parser [PVar (RType BTyCon BTyVar ())]
-> Parser [PVar (RType BTyCon BTyVar ())]
-> Parser [PVar (RType BTyCon BTyVar ())]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [PVar (RType BTyCon BTyVar ())]
-> Parser [PVar (RType BTyCon BTyVar ())]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
  [Char]
_ <- StateT PState (Parsec Void [Char]) [Char]
dot
  RType BTyCon BTyVar RReft
t <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP
  RType BTyCon BTyVar RReft
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RType BTyCon BTyVar RReft
 -> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft))
-> RType BTyCon BTyVar RReft
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a b. (a -> b) -> a -> b
$ (RTVar BTyVar (RType BTyCon BTyVar ())
 -> RType BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft)
-> RType BTyCon BTyVar RReft
-> [RTVar BTyVar (RType BTyCon BTyVar ())]
-> RType BTyCon BTyVar RReft
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr RTVar BTyVar (RType BTyCon BTyVar ())
-> RType BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft
forall {r} {c} {tv}.
Monoid r =>
RTVU c tv -> RType c tv r -> RType c tv r
rAllT ((PVar (RType BTyCon BTyVar ())
 -> RType BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft)
-> RType BTyCon BTyVar RReft
-> [PVar (RType BTyCon BTyVar ())]
-> RType BTyCon BTyVar RReft
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (SourcePos
-> PVar (RType BTyCon BTyVar ())
-> RType BTyCon BTyVar RReft
-> RType BTyCon BTyVar RReft
rAllP SourcePos
sp) RType BTyCon BTyVar RReft
t [PVar (RType BTyCon BTyVar ())]
ps) (BTyVar -> RTVar BTyVar (RType BTyCon BTyVar ())
forall tv s. tv -> RTVar tv s
makeRTVar (BTyVar -> RTVar BTyVar (RType BTyCon BTyVar ()))
-> [BTyVar] -> [RTVar BTyVar (RType BTyCon BTyVar ())]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [BTyVar]
as)
  where
    rAllT :: RTVU c tv -> RType c tv r -> RType c tv r
rAllT RTVU c tv
a RType c tv r
t = RTVU c tv -> RType c tv r -> r -> RType c tv r
forall c tv r. RTVU c tv -> RType c tv r -> r -> RType c tv r
RAllT RTVU c tv
a RType c tv r
t r
forall a. Monoid a => a
mempty
    inAngles :: Parser [PVar (RType BTyCon BTyVar ())]
inAngles  = Parser [PVar (RType BTyCon BTyVar ())]
-> Parser [PVar (RType BTyCon BTyVar ())]
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try  (StateT PState (Parsec Void [Char]) (PVar (RType BTyCon BTyVar ()))
-> StateT PState (Parsec Void [Char]) [Char]
-> Parser [PVar (RType BTyCon BTyVar ())]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy  StateT PState (Parsec Void [Char]) (PVar (RType BTyCon BTyVar ()))
predVarDefP StateT PState (Parsec Void [Char]) [Char]
comma)

-- See #1907 for why we have to alpha-rename pvar binders
rAllP :: SourcePos -> PVar BSort -> BareType -> BareType
rAllP :: SourcePos
-> PVar (RType BTyCon BTyVar ())
-> RType BTyCon BTyVar RReft
-> RType BTyCon BTyVar RReft
rAllP SourcePos
sp PVar (RType BTyCon BTyVar ())
p RType BTyCon BTyVar RReft
t = PVar (RType BTyCon BTyVar ())
-> RType BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft
forall c tv r. PVU c tv -> RType c tv r -> RType c tv r
RAllP PVar (RType BTyCon BTyVar ())
p' ({- F.tracepp "rAllP" $ -} PVar (RType BTyCon BTyVar ())
-> PVar (RType BTyCon BTyVar ())
-> RType BTyCon BTyVar RReft
-> RType BTyCon BTyVar RReft
substPVar PVar (RType BTyCon BTyVar ())
p PVar (RType BTyCon BTyVar ())
p' RType BTyCon BTyVar RReft
t)
  where
    p' :: PVar (RType BTyCon BTyVar ())
p'  = PVar (RType BTyCon BTyVar ())
p { pname = pn' }
    pn' :: Symbol
pn' = PVar (RType BTyCon BTyVar ()) -> Symbol
forall t. PVar t -> Symbol
pname PVar (RType 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 a. Parser a -> Parser a
parens (StateT PState (Parsec Void [Char]) BTyVar -> Parser [BTyVar]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (Symbol -> BTyVar
bTyVar (Symbol -> BTyVar)
-> Parser Symbol -> StateT PState (Parsec Void [Char]) BTyVar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
tyKindVarIdP))
 Parser [BTyVar] -> Parser [BTyVar] -> Parser [BTyVar]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT PState (Parsec Void [Char]) BTyVar -> Parser [BTyVar]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (Symbol -> BTyVar
bTyVar (Symbol -> BTyVar)
-> Parser Symbol -> StateT PState (Parsec Void [Char]) BTyVar
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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
   Symbol
tv <- Parser Symbol
tyVarIdP
   do [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"::"; RType BTyCon BTyVar RReft
_ <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
kindP; Symbol -> Parser Symbol
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Symbol
tv Parser Symbol -> Parser Symbol -> Parser Symbol
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Symbol -> Parser Symbol
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Symbol
tv

kindP :: Parser BareType
kindP :: StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
kindP = StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareAtomBindP

predVarDefsP :: Parser [PVar BSort]
predVarDefsP :: Parser [PVar (RType BTyCon BTyVar ())]
predVarDefsP
  =  Parser [PVar (RType BTyCon BTyVar ())]
-> Parser [PVar (RType BTyCon BTyVar ())]
forall a. Parser a -> Parser a
angles (StateT PState (Parsec Void [Char]) (PVar (RType BTyCon BTyVar ()))
-> StateT PState (Parsec Void [Char]) [Char]
-> Parser [PVar (RType BTyCon BTyVar ())]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy1 StateT PState (Parsec Void [Char]) (PVar (RType BTyCon BTyVar ()))
predVarDefP StateT PState (Parsec Void [Char]) [Char]
comma)
 Parser [PVar (RType BTyCon BTyVar ())]
-> Parser [PVar (RType BTyCon BTyVar ())]
-> Parser [PVar (RType BTyCon BTyVar ())]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [PVar (RType BTyCon BTyVar ())]
-> Parser [PVar (RType BTyCon BTyVar ())]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
 Parser [PVar (RType BTyCon BTyVar ())]
-> [Char] -> Parser [PVar (RType BTyCon BTyVar ())]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"predVarDefP"

predVarDefP :: Parser (PVar BSort)
predVarDefP :: StateT PState (Parsec Void [Char]) (PVar (RType BTyCon BTyVar ()))
predVarDefP
  = Symbol
-> ()
-> [(Symbol, RType BTyCon BTyVar ())]
-> PVar (RType BTyCon BTyVar ())
forall t t1. Symbol -> t -> [(Symbol, t1)] -> PVar t1
bPVar (Symbol
 -> ()
 -> [(Symbol, RType BTyCon BTyVar ())]
 -> PVar (RType BTyCon BTyVar ()))
-> Parser Symbol
-> StateT
     PState
     (Parsec Void [Char])
     (()
      -> [(Symbol, RType BTyCon BTyVar ())]
      -> PVar (RType BTyCon BTyVar ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
predVarIdP StateT
  PState
  (Parsec Void [Char])
  (()
   -> [(Symbol, RType BTyCon BTyVar ())]
   -> PVar (RType BTyCon BTyVar ()))
-> StateT PState (Parsec Void [Char]) ()
-> StateT
     PState
     (Parsec Void [Char])
     ([(Symbol, RType BTyCon BTyVar ())]
      -> PVar (RType BTyCon BTyVar ()))
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"::" StateT
  PState
  (Parsec Void [Char])
  ([(Symbol, RType BTyCon BTyVar ())]
   -> PVar (RType BTyCon BTyVar ()))
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar ())]
-> StateT
     PState (Parsec Void [Char]) (PVar (RType BTyCon BTyVar ()))
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT
  PState (Parsec Void [Char]) [(Symbol, RType 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)] -> PVar t1
bPVar :: forall t t1. Symbol -> t -> [(Symbol, t1)] -> PVar t1
bPVar Symbol
p t
_ [(Symbol, t1)]
xts  = Symbol -> PVKind t1 -> Symbol -> [(t1, Symbol, Expr)] -> PVar t1
forall t.
Symbol -> PVKind t -> Symbol -> [(t, Symbol, Expr)] -> PVar t
PV Symbol
p (t1 -> PVKind t1
forall t. t -> PVKind t
PVProp t1
τ) Symbol
dummySymbol [(t1, Symbol, Expr)]
τxs
  where
    (Symbol
_, t1
τ) = [Char] -> [(Symbol, t1)] -> (Symbol, t1)
forall {a}. [Char] -> [a] -> a
safeLast [Char]
"bPVar last" [(Symbol, t1)]
xts
    τxs :: [(t1, Symbol, Expr)]
τxs    = [ (t1
τ', Symbol
x, Symbol -> Expr
EVar 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. 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, BSort)]
propositionSortP :: StateT
  PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar ())]
propositionSortP = ((Symbol, RType BTyCon BTyVar RReft)
 -> (Symbol, RType BTyCon BTyVar ()))
-> [(Symbol, RType BTyCon BTyVar RReft)]
-> [(Symbol, RType BTyCon BTyVar ())]
forall a b. (a -> b) -> [a] -> [b]
map ((RType BTyCon BTyVar RReft -> RType BTyCon BTyVar ())
-> (Symbol, RType BTyCon BTyVar RReft)
-> (Symbol, RType BTyCon BTyVar ())
forall b c a. (b -> c) -> (a, b) -> (a, c)
Misc.mapSnd RType BTyCon BTyVar RReft -> RType BTyCon BTyVar ()
forall c tv r. RType c tv r -> RType c tv ()
toRSort) ([(Symbol, RType BTyCon BTyVar RReft)]
 -> [(Symbol, RType BTyCon BTyVar ())])
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar ())]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
propositionTypeP

propositionTypeP :: Parser [(Symbol, BareType)]
propositionTypeP :: StateT
  PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
propositionTypeP = ([Char]
 -> StateT
      PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)])
-> ([(Symbol, RType BTyCon BTyVar RReft)]
    -> StateT
         PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)])
-> Either [Char] [(Symbol, RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either [Char]
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
forall a. [Char] -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [(Symbol, RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [Char] [(Symbol, RType BTyCon BTyVar RReft)]
 -> StateT
      PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)])
-> (RType BTyCon BTyVar RReft
    -> Either [Char] [(Symbol, RType BTyCon BTyVar RReft)])
-> RType BTyCon BTyVar RReft
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RType BTyCon BTyVar RReft
-> Either [Char] [(Symbol, RType BTyCon BTyVar RReft)]
mkPropositionType (RType BTyCon BTyVar RReft
 -> StateT
      PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)])
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP

mkPropositionType :: BareType -> Either String [(Symbol, BareType)]
mkPropositionType :: RType BTyCon BTyVar RReft
-> Either [Char] [(Symbol, RType BTyCon BTyVar RReft)]
mkPropositionType RType BTyCon BTyVar RReft
t
  | Bool
isOk      = [(Symbol, RType BTyCon BTyVar RReft)]
-> Either [Char] [(Symbol, RType BTyCon BTyVar RReft)]
forall a b. b -> Either a b
Right ([(Symbol, RType BTyCon BTyVar RReft)]
 -> Either [Char] [(Symbol, RType BTyCon BTyVar RReft)])
-> [(Symbol, RType BTyCon BTyVar RReft)]
-> Either [Char] [(Symbol, RType BTyCon BTyVar RReft)]
forall a b. (a -> b) -> a -> b
$ [Symbol]
-> [RType BTyCon BTyVar RReft]
-> [(Symbol, RType BTyCon BTyVar RReft)]
forall a b. [a] -> [b] -> [(a, b)]
zip (RTypeRep BTyCon BTyVar RReft -> [Symbol]
forall c tv r. RTypeRep c tv r -> [Symbol]
ty_binds RTypeRep BTyCon BTyVar RReft
tRep) (RTypeRep BTyCon BTyVar RReft -> [RType BTyCon BTyVar RReft]
forall c tv r. RTypeRep c tv r -> [RType c tv r]
ty_args RTypeRep BTyCon BTyVar RReft
tRep)
  | Bool
otherwise = [Char] -> Either [Char] [(Symbol, RType BTyCon BTyVar RReft)]
forall a b. a -> Either a b
Left [Char]
mkErr
  where
    isOk :: Bool
isOk      = RType BTyCon BTyVar RReft -> Bool
forall t t1. RType BTyCon t t1 -> Bool
isPropBareType (RTypeRep BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft
forall c tv r. RTypeRep c tv r -> RType c tv r
ty_res RTypeRep BTyCon BTyVar RReft
tRep)
    tRep :: RTypeRep BTyCon BTyVar RReft
tRep      = RType BTyCon BTyVar RReft -> RTypeRep BTyCon BTyVar RReft
forall c tv r. RType c tv r -> RTypeRep c tv r
toRTypeRep RType BTyCon BTyVar RReft
t
    mkErr :: [Char]
mkErr     = [Char]
"Proposition type with non-Bool output: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ RType BTyCon BTyVar RReft -> [Char]
forall a. PPrint a => a -> [Char]
showpp RType BTyCon BTyVar RReft
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 PState (Parsec Void [Char]) (y -> (x, y))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser x
lP StateT PState (Parsec Void [Char]) (y -> (x, y))
-> Parser a -> StateT PState (Parsec Void [Char]) (y -> (x, y))
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser a
sepP StateT PState (Parsec Void [Char]) (y -> (x, y))
-> Parser y -> StateT PState (Parsec Void [Char]) (x, y)
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (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 PState (Parsec Void [Char]) Integer -> Parser Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) Integer
freshIntP

isPropBareType :: RType BTyCon t t1 -> Bool
isPropBareType :: forall t t1. RType BTyCon t t1 -> Bool
isPropBareType  = Symbol -> RType BTyCon t t1 -> Bool
forall t t1. Symbol -> RType BTyCon t t1 -> Bool
isPrimBareType Symbol
boolConName

isPrimBareType :: Symbol -> RType BTyCon t t1 -> Bool
isPrimBareType :: forall t t1. Symbol -> RType BTyCon t t1 -> Bool
isPrimBareType Symbol
n (RApp BTyCon
tc [] [RTProp BTyCon t t1]
_ t1
_) = LocSymbol -> Symbol
forall a. Located a -> a
val (BTyCon -> LocSymbol
btc_tc BTyCon
tc) Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== Symbol
n
isPrimBareType Symbol
_ RType BTyCon t t1
_                = Bool
False

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

dummyP ::  Monad m => m (Reft -> b) -> m b
dummyP :: forall (m :: * -> *) b. Monad m => m (Reft -> b) -> m b
dummyP m (Reft -> b)
fm
  = m (Reft -> b)
fm m (Reft -> b) -> m Reft -> m b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
`ap` Reft -> m Reft
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Reft
forall a. Monoid a => a
dummyReft

symsP :: (IsString tv, Monoid r)
      => Parser [(Symbol, RType c tv r)]
symsP :: forall tv r c.
(IsString tv, Monoid r) =>
Parser [(Symbol, RType c tv r)]
symsP
  = do [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"\\"
       [Symbol]
ss <- Parser Symbol -> StateT PState (Parsec Void [Char]) [Symbol]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many Parser Symbol
symbolP
       [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"->"
       [(Symbol, RType c tv r)]
-> StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([(Symbol, RType c tv r)]
 -> StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)])
-> [(Symbol, RType c tv r)]
-> StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
forall a b. (a -> b) -> a -> b
$ (, RType c tv r
forall tv r c. (IsString tv, Monoid r) => RType c tv r
dummyRSort) (Symbol -> (Symbol, RType c tv r))
-> [Symbol] -> [(Symbol, RType c tv r)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol]
ss
 StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
-> StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
-> StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [(Symbol, RType c tv r)]
-> StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
 StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
-> [Char]
-> StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"symsP"

dummyRSort :: (IsString tv, Monoid r) => RType c tv r
dummyRSort :: forall tv r c. (IsString tv, Monoid r) => RType c tv r
dummyRSort
  = tv -> r -> RType c tv r
forall c tv r. tv -> r -> RType c tv r
RVar tv
"dummy" r
forall a. Monoid a => a
mempty

predicatesP :: (IsString tv, Monoid r)
            => Parser [Ref (RType c tv r) BareType]
predicatesP :: forall tv r c.
(IsString tv, Monoid r) =>
Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
predicatesP
   =  Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
-> Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
forall a. Parser a -> Parser a
angles (StateT
  PState
  (Parsec Void [Char])
  (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) [Char]
-> Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy1 StateT
  PState
  (Parsec Void [Char])
  (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall tv r c.
(IsString tv, Monoid r) =>
Parser (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
predicate1P StateT PState (Parsec Void [Char]) [Char]
comma)
  Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
-> Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
-> Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
-> Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
  Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
-> [Char]
-> Parser [Ref (RType c tv r) (RType BTyCon BTyVar RReft)]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"predicatesP"

predicate1P :: (IsString tv, Monoid r)
            => Parser (Ref (RType c tv r) BareType)
predicate1P :: forall tv r c.
(IsString tv, Monoid r) =>
Parser (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
predicate1P
   =  StateT
  PState
  (Parsec Void [Char])
  (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ([(Symbol, RType c tv r)]
-> RType BTyCon BTyVar RReft
-> Ref (RType c tv r) (RType BTyCon BTyVar RReft)
forall τ t. [(Symbol, τ)] -> t -> Ref τ t
RProp ([(Symbol, RType c tv r)]
 -> RType BTyCon BTyVar RReft
 -> Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
-> StateT
     PState
     (Parsec Void [Char])
     (RType BTyCon BTyVar RReft
      -> Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) [(Symbol, RType c tv r)]
forall tv r c.
(IsString tv, Monoid r) =>
Parser [(Symbol, RType c tv r)]
symsP StateT
  PState
  (Parsec Void [Char])
  (RType BTyCon BTyVar RReft
   -> Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
refP StateT
  PState (Parsec Void [Char]) (Reft -> RType BTyCon BTyVar RReft)
bbaseP)
  StateT
  PState
  (Parsec Void [Char])
  (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([(Symbol, RType c tv r)]
-> RReft -> Ref (RType c tv r) (RType BTyCon BTyVar RReft)
forall τ r c tv. [(Symbol, τ)] -> r -> Ref τ (RType c tv r)
rPropP [] (RReft -> Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> (Predicate -> RReft)
-> Predicate
-> Ref (RType c tv r) (RType BTyCon BTyVar RReft)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Predicate -> RReft
forall r. Monoid r => Predicate -> UReft r
predUReft (Predicate -> Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> Parser Predicate
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Predicate
monoPredicate1P)
  StateT
  PState
  (Parsec Void [Char])
  (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  PState
  (Parsec Void [Char])
  (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
braces ([((Symbol, RType c tv r), Symbol)]
-> Expr -> Ref (RType c tv r) (RType BTyCon BTyVar RReft)
forall τ c.
[((Symbol, τ), Symbol)] -> Expr -> Ref τ (RType c BTyVar RReft)
bRProp ([((Symbol, RType c tv r), Symbol)]
 -> Expr -> Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> StateT
     PState (Parsec Void [Char]) [((Symbol, RType c tv r), Symbol)]
-> StateT
     PState
     (Parsec Void [Char])
     (Expr -> Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  PState (Parsec Void [Char]) [((Symbol, RType c tv r), Symbol)]
forall {tv} {r} {c}.
(IsString tv, Monoid r) =>
StateT
  PState (Parsec Void [Char]) [((Symbol, RType c tv r), Symbol)]
symsP' StateT
  PState
  (Parsec Void [Char])
  (Expr -> Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> Parser Expr
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
refaP)
  StateT
  PState
  (Parsec Void [Char])
  (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
-> [Char]
-> StateT
     PState
     (Parsec Void [Char])
     (Ref (RType c tv r) (RType BTyCon BTyVar RReft))
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"predicate1P"
   where
    symsP' :: StateT
  PState (Parsec Void [Char]) [((Symbol, RType c tv r), Symbol)]
symsP'       = do [(Symbol, RType c tv r)]
ss    <- Parser [(Symbol, RType c tv r)]
forall tv r c.
(IsString tv, Monoid r) =>
Parser [(Symbol, RType c tv r)]
symsP
                      [Symbol]
fs    <- (Symbol -> Parser Symbol)
-> [Symbol] -> StateT PState (Parsec Void [Char]) [Symbol]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Symbol -> Parser Symbol
refreshSym ((Symbol, RType c tv r) -> Symbol
forall a b. (a, b) -> a
fst ((Symbol, RType c tv r) -> Symbol)
-> [(Symbol, RType c tv r)] -> [Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Symbol, RType c tv r)]
ss)
                      [((Symbol, RType c tv r), Symbol)]
-> StateT
     PState (Parsec Void [Char]) [((Symbol, RType c tv r), Symbol)]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([((Symbol, RType c tv r), Symbol)]
 -> StateT
      PState (Parsec Void [Char]) [((Symbol, RType c tv r), Symbol)])
-> [((Symbol, RType c tv r), Symbol)]
-> StateT
     PState (Parsec Void [Char]) [((Symbol, RType c tv r), Symbol)]
forall a b. (a -> b) -> a -> b
$ [(Symbol, RType c tv r)]
-> [Symbol] -> [((Symbol, RType c tv r), Symbol)]
forall a b. [a] -> [b] -> [(a, b)]
zip [(Symbol, RType c tv r)]
ss [Symbol]
fs
    refreshSym :: Symbol -> Parser Symbol
refreshSym Symbol
s = Symbol -> Integer -> Symbol
forall a. Show a => Symbol -> a -> Symbol
intSymbol Symbol
s (Integer -> Symbol)
-> StateT PState (Parsec Void [Char]) Integer -> Parser Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) Integer
freshIntP

mmonoPredicateP :: Parser Predicate
mmonoPredicateP :: Parser Predicate
mmonoPredicateP
   = Parser Predicate -> Parser Predicate
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser Predicate -> Parser Predicate
forall a. Parser a -> Parser a
angles (Parser Predicate -> Parser Predicate)
-> Parser Predicate -> Parser Predicate
forall a b. (a -> b) -> a -> b
$ Parser Predicate -> Parser Predicate
forall a. Parser a -> Parser a
angles Parser Predicate
monoPredicate1P)
  Parser Predicate -> Parser Predicate -> Parser Predicate
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Predicate -> Parser Predicate
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Predicate
forall a. Monoid a => a
mempty
  Parser Predicate -> [Char] -> Parser Predicate
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"mmonoPredicateP"

monoPredicateP :: Parser Predicate
monoPredicateP :: Parser Predicate
monoPredicateP
   = Parser Predicate -> Parser Predicate
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser Predicate -> Parser Predicate
forall a. Parser a -> Parser a
angles Parser Predicate
monoPredicate1P)
  Parser Predicate -> Parser Predicate -> Parser Predicate
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Predicate -> Parser Predicate
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Predicate
forall a. Monoid a => a
mempty
  Parser Predicate -> [Char] -> Parser Predicate
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"monoPredicateP"

monoPredicate1P :: Parser Predicate
monoPredicate1P :: Parser Predicate
monoPredicate1P
   =  ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"True" StateT PState (Parsec Void [Char]) ()
-> Parser Predicate -> Parser Predicate
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Predicate -> Parser Predicate
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Predicate
forall a. Monoid a => a
mempty)
  Parser Predicate -> Parser Predicate -> Parser Predicate
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (PVar [Char] -> Predicate
forall t. PVar t -> Predicate
pdVar (PVar [Char] -> Predicate)
-> StateT PState (Parsec Void [Char]) (PVar [Char])
-> Parser Predicate
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (PVar [Char])
-> StateT PState (Parsec Void [Char]) (PVar [Char])
forall a. Parser a -> Parser a
parens StateT PState (Parsec Void [Char]) (PVar [Char])
predVarUseP)
  Parser Predicate -> Parser Predicate -> Parser Predicate
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (PVar [Char] -> Predicate
forall t. PVar t -> Predicate
pdVar (PVar [Char] -> Predicate)
-> StateT PState (Parsec Void [Char]) (PVar [Char])
-> Parser Predicate
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>        StateT PState (Parsec Void [Char]) (PVar [Char])
predVarUseP)
  Parser Predicate -> [Char] -> Parser Predicate
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"monoPredicate1P"

predVarUseP :: Parser (PVar String)
predVarUseP :: StateT PState (Parsec Void [Char]) (PVar [Char])
predVarUseP
  = do (Symbol
p, ListNE Expr
xs) <- Parser (Symbol, ListNE Expr)
funArgsP
       PVar [Char] -> StateT PState (Parsec Void [Char]) (PVar [Char])
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return   (PVar [Char] -> StateT PState (Parsec Void [Char]) (PVar [Char]))
-> PVar [Char] -> StateT PState (Parsec Void [Char]) (PVar [Char])
forall a b. (a -> b) -> a -> b
$ Symbol
-> PVKind [Char]
-> Symbol
-> [([Char], Symbol, Expr)]
-> PVar [Char]
forall t.
Symbol -> PVKind t -> Symbol -> [(t, Symbol, Expr)] -> PVar t
PV Symbol
p ([Char] -> PVKind [Char]
forall t. t -> PVKind t
PVProp [Char]
forall a. IsString a => a
dummyTyId) Symbol
dummySymbol [ ([Char]
forall a. IsString a => a
dummyTyId, Symbol
dummySymbol, Expr
x) | Expr
x <- ListNE Expr
xs ]

funArgsP :: Parser (Symbol, [Expr])
funArgsP :: Parser (Symbol, ListNE Expr)
funArgsP  = Parser (Symbol, ListNE Expr) -> Parser (Symbol, ListNE Expr)
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser (Symbol, ListNE Expr)
realP Parser (Symbol, ListNE Expr)
-> Parser (Symbol, ListNE Expr) -> Parser (Symbol, ListNE Expr)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Symbol, ListNE Expr)
forall {a}. StateT PState (Parsec Void [Char]) (Symbol, [a])
empP Parser (Symbol, ListNE Expr)
-> [Char] -> Parser (Symbol, ListNE Expr)
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"funArgsP"
  where
    empP :: StateT PState (Parsec Void [Char]) (Symbol, [a])
empP  = (,[]) (Symbol -> (Symbol, [a]))
-> Parser Symbol
-> StateT PState (Parsec Void [Char]) (Symbol, [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
predVarIdP
    realP :: Parser (Symbol, ListNE Expr)
realP = do (EVar Symbol
lp, ListNE Expr
xs) <- Expr -> (Expr, ListNE Expr)
splitEApp (Expr -> (Expr, ListNE Expr))
-> Parser Expr
-> StateT PState (Parsec Void [Char]) (Expr, ListNE Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
funAppP
               (Symbol, ListNE Expr) -> Parser (Symbol, ListNE Expr)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Symbol
lp, ListNE Expr
xs)

boundP :: Parser (Bound (Located BareType) Expr)
boundP :: Parser (Bound (Located (RType BTyCon BTyVar RReft)) Expr)
boundP = do
  LocSymbol
name   <- StateT PState (Parsec Void [Char]) LocSymbol
locUpperIdP
  [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"="
  [Located (RType BTyCon BTyVar RReft)]
vs      <- StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall {r} {c}.
Monoid r =>
StateT PState (Parsec Void [Char]) [Located (RType c BTyVar r)]
bvsP
  [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
params' <- StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
parens StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
tyBindP)
  [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
args    <- StateT
  PState
  (Parsec Void [Char])
  [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
bargsP
  LocSymbol
-> [Located (RType BTyCon BTyVar RReft)]
-> [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
-> [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
-> Expr
-> Bound (Located (RType BTyCon BTyVar RReft)) Expr
forall t e.
LocSymbol
-> [t] -> [(LocSymbol, t)] -> [(LocSymbol, t)] -> e -> Bound t e
Bound LocSymbol
name [Located (RType BTyCon BTyVar RReft)]
vs [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
params' [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
args (Expr -> Bound (Located (RType BTyCon BTyVar RReft)) Expr)
-> Parser Expr
-> Parser (Bound (Located (RType BTyCon BTyVar RReft)) Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
predP
 where
    bargsP :: StateT
  PState
  (Parsec Void [Char])
  [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
bargsP =     ( do [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"\\"
                      [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
xs <- StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
parens StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
tyBindP)
                      [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp  [Char]
"->"
                      [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
-> StateT
     PState
     (Parsec Void [Char])
     [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
xs
                 )
           StateT
  PState
  (Parsec Void [Char])
  [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
-> StateT
     PState
     (Parsec Void [Char])
     [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
-> StateT
     PState
     (Parsec Void [Char])
     [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
-> StateT
     PState
     (Parsec Void [Char])
     [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []
           StateT
  PState
  (Parsec Void [Char])
  [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
-> [Char]
-> StateT
     PState
     (Parsec Void [Char])
     [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"bargsP"
    bvsP :: StateT PState (Parsec Void [Char]) [Located (RType c BTyVar r)]
bvsP   =     ( do [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"forall"
                      [Located BTyVar]
xs <- StateT PState (Parsec Void [Char]) (Located BTyVar)
-> StateT PState (Parsec Void [Char]) [Located BTyVar]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many ((Symbol -> BTyVar) -> LocSymbol -> Located BTyVar
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Symbol -> BTyVar
bTyVar (LocSymbol -> Located BTyVar)
-> StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) (Located BTyVar)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) LocSymbol
locSymbolP)
                      [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp  [Char]
"."
                      [Located (RType c BTyVar r)]
-> StateT PState (Parsec Void [Char]) [Located (RType c BTyVar r)]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ((BTyVar -> RType c BTyVar r)
-> Located BTyVar -> Located (RType c BTyVar r)
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (BTyVar -> r -> RType c BTyVar r
forall c tv r. tv -> r -> RType c tv r
`RVar` r
forall a. Monoid a => a
mempty) (Located BTyVar -> Located (RType c BTyVar r))
-> [Located BTyVar] -> [Located (RType c BTyVar r)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Located BTyVar]
xs)
                 )
           StateT PState (Parsec Void [Char]) [Located (RType c BTyVar r)]
-> StateT PState (Parsec Void [Char]) [Located (RType c BTyVar r)]
-> StateT PState (Parsec Void [Char]) [Located (RType c BTyVar r)]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Located (RType c BTyVar r)]
-> StateT PState (Parsec Void [Char]) [Located (RType c BTyVar r)]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []


infixGenP :: Assoc -> Parser ()
infixGenP :: Assoc -> StateT PState (Parsec Void [Char]) ()
infixGenP Assoc
assoc = do
   Maybe Int
p <- Parser (Maybe Int)
maybeDigit
   Symbol
s <- Parser Symbol
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
   Fixity -> StateT PState (Parsec Void [Char]) ()
addOperatorP (Maybe Int
-> [Char] -> Maybe (Expr -> Expr -> Expr) -> Assoc -> Fixity
FInfix Maybe Int
p (Symbol -> [Char]
symbolString Symbol
s) Maybe (Expr -> Expr -> Expr)
forall a. Maybe a
Nothing Assoc
assoc)

infixP :: Parser ()
infixP :: StateT PState (Parsec Void [Char]) ()
infixP = Assoc -> StateT PState (Parsec Void [Char]) ()
infixGenP Assoc
AssocLeft

infixlP :: Parser ()
infixlP :: StateT PState (Parsec Void [Char]) ()
infixlP = Assoc -> StateT PState (Parsec Void [Char]) ()
infixGenP Assoc
AssocLeft

infixrP :: Parser ()
infixrP :: StateT PState (Parsec Void [Char]) ()
infixrP = Assoc -> StateT PState (Parsec Void [Char]) ()
infixGenP Assoc
AssocRight

maybeDigit :: Parser (Maybe Int)
maybeDigit :: Parser (Maybe Int)
maybeDigit
  = StateT PState (Parsec Void [Char]) Int -> Parser (Maybe Int)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (StateT PState (Parsec Void [Char]) Int
-> StateT PState (Parsec Void [Char]) Int
forall a. Parser a -> Parser 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 PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) Char
StateT PState (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)]
       -> Expr -> Ref τ (RType c BTyVar (UReft Reft))
bRProp :: forall τ c.
[((Symbol, τ), Symbol)] -> Expr -> Ref τ (RType c BTyVar RReft)
bRProp []    Expr
_    = Maybe SrcSpan -> [Char] -> Ref τ (RType c BTyVar RReft)
forall a. Maybe SrcSpan -> [Char] -> a
panic Maybe SrcSpan
forall a. Maybe a
Nothing [Char]
"Parse.bRProp empty list"
bRProp [((Symbol, τ), Symbol)]
syms' Expr
epr  = [(Symbol, τ)]
-> RType c BTyVar RReft -> Ref τ (RType c BTyVar RReft)
forall τ t. [(Symbol, τ)] -> t -> Ref τ t
RProp [(Symbol, τ)]
ss (RType c BTyVar RReft -> Ref τ (RType c BTyVar RReft))
-> RType c BTyVar RReft -> Ref τ (RType c BTyVar RReft)
forall a b. (a -> b) -> a -> b
$ BTyVar -> Predicate -> Reft -> RType c BTyVar RReft
forall tv r c. tv -> Predicate -> r -> RType c tv (UReft r)
bRVar (Symbol -> BTyVar
BTV Symbol
dummyName) Predicate
forall a. Monoid a => a
mempty Reft
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 :: Subst
su            = [(Symbol, Expr)] -> Subst
mkSubst [(Symbol
x, Symbol -> Expr
EVar Symbol
y) | ((Symbol
x, τ
_), Symbol
y) <- [((Symbol, τ), Symbol)]
syms']
    r :: Reft
r             = Subst
su Subst -> Reft -> Reft
forall a. Subable a => Subst -> a -> a
`subst` (Symbol, Expr) -> Reft
Reft (Symbol
v, Expr
epr)

bRVar :: tv -> Predicate -> r -> RType c tv (UReft r)
bRVar :: forall tv r c. tv -> Predicate -> r -> RType c tv (UReft r)
bRVar tv
α Predicate
p r
r = tv -> UReft r -> RType c tv (UReft r)
forall c tv r. tv -> r -> RType c tv r
RVar tv
α (r -> Predicate -> UReft r
forall r. r -> Predicate -> UReft r
MkUReft r
r Predicate
p)

bLst :: Maybe (RType BTyCon tv (UReft r))
     -> [RTProp BTyCon tv (UReft r)]
     -> r
     -> RType BTyCon tv (UReft r)
bLst :: forall tv r.
Maybe (RType BTyCon tv (UReft r))
-> [RTProp BTyCon tv (UReft r)] -> r -> RType BTyCon tv (UReft r)
bLst (Just RType BTyCon tv (UReft r)
t) [RTProp BTyCon tv (UReft r)]
rs r
r = BTyCon
-> [RType BTyCon tv (UReft r)]
-> [RTProp BTyCon tv (UReft r)]
-> UReft r
-> RType BTyCon tv (UReft r)
forall c tv r.
c -> [RType c tv r] -> [RTProp c tv r] -> r -> RType c tv r
RApp (LocSymbol -> BTyCon
mkBTyCon (LocSymbol -> BTyCon) -> LocSymbol -> BTyCon
forall a b. (a -> b) -> a -> b
$ Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc Symbol
listConName) [RType BTyCon tv (UReft r)
t] [RTProp BTyCon tv (UReft r)]
rs (r -> UReft r
forall r. r -> UReft r
reftUReft r
r)
bLst Maybe (RType BTyCon tv (UReft r))
Nothing  [RTProp BTyCon tv (UReft r)]
rs r
r = BTyCon
-> [RType BTyCon tv (UReft r)]
-> [RTProp BTyCon tv (UReft r)]
-> UReft r
-> RType BTyCon tv (UReft r)
forall c tv r.
c -> [RType c tv r] -> [RTProp c tv r] -> r -> RType c tv r
RApp (LocSymbol -> BTyCon
mkBTyCon (LocSymbol -> BTyCon) -> LocSymbol -> BTyCon
forall a b. (a -> b) -> a -> b
$ Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc Symbol
listConName) []  [RTProp BTyCon tv (UReft r)]
rs (r -> UReft r
forall r. r -> UReft r
reftUReft r
r)

bTup :: (PPrint r, Reftable r, Reftable (RType BTyCon BTyVar (UReft r)), Reftable (RTProp BTyCon BTyVar (UReft r)))
     => [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
     -> [RTProp BTyCon BTyVar (UReft r)]
     -> r
     -> RType BTyCon BTyVar (UReft r)
bTup :: forall r.
(PPrint r, Reftable r, Reftable (RType BTyCon BTyVar (UReft r)),
 Reftable (RTProp BTyCon BTyVar (UReft r))) =>
[(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
-> [RTProp BTyCon BTyVar (UReft r)]
-> r
-> RType BTyCon BTyVar (UReft r)
bTup [(Maybe Symbol
_,RType BTyCon BTyVar (UReft r)
t)] [RTProp BTyCon BTyVar (UReft r)]
_ r
r
  | r -> Bool
forall r. Reftable r => r -> Bool
isTauto r
r  = RType BTyCon BTyVar (UReft r)
t
  | Bool
otherwise  = RType BTyCon BTyVar (UReft r)
t RType BTyCon BTyVar (UReft r)
-> UReft r -> RType BTyCon BTyVar (UReft r)
forall r c tv. Reftable r => RType c tv r -> r -> RType c tv r
`strengthen` r -> UReft r
forall r. r -> UReft r
reftUReft r
r
bTup [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
ts [RTProp BTyCon BTyVar (UReft r)]
rs r
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, RType BTyCon BTyVar (UReft r)) -> Maybe Symbol
forall a b. (a, b) -> a
fst ((Maybe Symbol, RType BTyCon BTyVar (UReft r)) -> Maybe Symbol)
-> [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
-> [Maybe Symbol]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
ts) Bool -> Bool -> Bool
|| [(Maybe Symbol, RType BTyCon BTyVar (UReft r))] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
ts Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2
  = BTyCon
-> [RType BTyCon BTyVar (UReft r)]
-> [RTProp BTyCon BTyVar (UReft r)]
-> UReft r
-> RType BTyCon BTyVar (UReft r)
forall c tv r.
c -> [RType c tv r] -> [RTProp c tv r] -> r -> RType c tv r
RApp (LocSymbol -> BTyCon
mkBTyCon (LocSymbol -> BTyCon) -> LocSymbol -> BTyCon
forall a b. (a -> b) -> a -> b
$ Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc Symbol
tupConName) ((Maybe Symbol, RType BTyCon BTyVar (UReft r))
-> RType BTyCon BTyVar (UReft r)
forall a b. (a, b) -> b
snd ((Maybe Symbol, RType BTyCon BTyVar (UReft r))
 -> RType BTyCon BTyVar (UReft r))
-> [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
-> [RType BTyCon BTyVar (UReft r)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
ts) [RTProp BTyCon BTyVar (UReft r)]
rs (r -> UReft r
forall r. r -> UReft r
reftUReft r
r)
  | Bool
otherwise
  = BTyCon
-> [RType BTyCon BTyVar (UReft r)]
-> [RTProp BTyCon BTyVar (UReft r)]
-> UReft r
-> RType BTyCon BTyVar (UReft r)
forall c tv r.
c -> [RType c tv r] -> [RTProp c tv r] -> r -> RType c tv r
RApp (LocSymbol -> BTyCon
mkBTyCon (LocSymbol -> BTyCon) -> LocSymbol -> BTyCon
forall a b. (a -> b) -> a -> b
$ Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc Symbol
tupConName) (RType BTyCon BTyVar (UReft r) -> RType BTyCon BTyVar (UReft r)
forall r. Reftable r => r -> r
top (RType BTyCon BTyVar (UReft r) -> RType BTyCon BTyVar (UReft r))
-> ((Maybe Symbol, RType BTyCon BTyVar (UReft r))
    -> RType BTyCon BTyVar (UReft r))
-> (Maybe Symbol, RType BTyCon BTyVar (UReft r))
-> RType BTyCon BTyVar (UReft r)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Symbol, RType BTyCon BTyVar (UReft r))
-> RType BTyCon BTyVar (UReft r)
forall a b. (a, b) -> b
snd ((Maybe Symbol, RType BTyCon BTyVar (UReft r))
 -> RType BTyCon BTyVar (UReft r))
-> [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
-> [RType BTyCon BTyVar (UReft r)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
ts) [RTProp BTyCon BTyVar (UReft r)]
forall {r2}.
Monoid r2 =>
[Ref (RType BTyCon BTyVar r2) (RType BTyCon BTyVar (UReft r))]
rs' (r -> UReft r
forall r. r -> UReft r
reftUReft r
r)
  where
    args :: [(Symbol, RType BTyCon BTyVar r2)]
args       = [(Symbol -> Maybe Symbol -> Symbol
forall a. a -> Maybe a -> a
Mb.fromMaybe Symbol
dummySymbol Maybe Symbol
x, (UReft r -> r2)
-> RType BTyCon BTyVar (UReft r) -> RType BTyCon BTyVar r2
forall r1 r2 c tv. (r1 -> r2) -> RType c tv r1 -> RType c tv r2
mapReft UReft r -> r2
forall a. Monoid a => a
mempty RType BTyCon BTyVar (UReft r)
t) | (Maybe Symbol
x,RType BTyCon BTyVar (UReft r)
t) <- [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
ts]
    makeProp :: Int -> Ref (RType BTyCon BTyVar r2) (RType BTyCon BTyVar (UReft r))
makeProp Int
i = [(Symbol, RType BTyCon BTyVar r2)]
-> RType BTyCon BTyVar (UReft r)
-> Ref (RType BTyCon BTyVar r2) (RType BTyCon BTyVar (UReft r))
forall τ t. [(Symbol, τ)] -> t -> Ref τ t
RProp (Int
-> [(Symbol, RType BTyCon BTyVar r2)]
-> [(Symbol, RType BTyCon BTyVar r2)]
forall a. Int -> [a] -> [a]
take Int
i [(Symbol, RType BTyCon BTyVar r2)]
forall {r2}. Monoid r2 => [(Symbol, RType BTyCon BTyVar r2)]
args) (((Maybe Symbol, RType BTyCon BTyVar (UReft r))
-> RType BTyCon BTyVar (UReft r)
forall a b. (a, b) -> b
snd ((Maybe Symbol, RType BTyCon BTyVar (UReft r))
 -> RType BTyCon BTyVar (UReft r))
-> [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
-> [RType BTyCon BTyVar (UReft r)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
ts)[RType BTyCon BTyVar (UReft r)]
-> Int -> RType BTyCon BTyVar (UReft r)
forall a. HasCallStack => [a] -> Int -> a
!!Int
i)
    rs' :: [Ref (RType BTyCon BTyVar r2) (RType BTyCon BTyVar (UReft r))]
rs'        = Int -> Ref (RType BTyCon BTyVar r2) (RType BTyCon BTyVar (UReft r))
forall {r2}.
Monoid r2 =>
Int -> Ref (RType BTyCon BTyVar r2) (RType BTyCon BTyVar (UReft r))
makeProp (Int
 -> Ref (RType BTyCon BTyVar r2) (RType BTyCon BTyVar (UReft r)))
-> [Int]
-> [Ref (RType BTyCon BTyVar r2) (RType BTyCon BTyVar (UReft r))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int
1..([(Maybe Symbol, RType BTyCon BTyVar (UReft r))] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Maybe Symbol, RType BTyCon BTyVar (UReft r))]
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
     -> [RTProp c tv (UReft r)]
     -> [RType c tv (UReft r)]
     -> Predicate
     -> r
     -> RType c tv (UReft r)
bCon :: forall c tv r.
c
-> [RTProp c tv (UReft r)]
-> [RType c tv (UReft r)]
-> Predicate
-> r
-> RType c tv (UReft r)
bCon c
b [RTProp c tv (UReft r)]
rs [RType c tv (UReft r)]
ts Predicate
p r
r = c
-> [RType c tv (UReft r)]
-> [RTProp c tv (UReft r)]
-> UReft r
-> RType c tv (UReft r)
forall c tv r.
c -> [RType c tv r] -> [RTProp c tv r] -> r -> RType c tv r
RApp c
b [RType c tv (UReft r)]
ts [RTProp c tv (UReft r)]
rs (UReft r -> RType c tv (UReft r))
-> UReft r -> RType c tv (UReft r)
forall a b. (a -> b) -> a -> b
$ r -> Predicate -> UReft r
forall r. r -> Predicate -> UReft r
MkUReft r
r Predicate
p

bAppTy :: (Foldable t, PPrint r, Reftable r)
       => tv -> t (RType c tv (UReft r)) -> r -> RType c tv (UReft r)
bAppTy :: forall (t :: * -> *) r tv c.
(Foldable t, PPrint r, Reftable r) =>
tv -> t (RType c tv (UReft r)) -> r -> RType c tv (UReft r)
bAppTy tv
v t (RType c tv (UReft r))
ts r
r  = RType c tv (UReft r)
ts' RType c tv (UReft r) -> UReft r -> RType c tv (UReft r)
forall r c tv. Reftable r => RType c tv r -> r -> RType c tv r
`strengthen` r -> UReft r
forall r. r -> UReft r
reftUReft r
r
  where
    ts' :: RType c tv (UReft r)
ts'        = (RType c tv (UReft r)
 -> RType c tv (UReft r) -> RType c tv (UReft r))
-> RType c tv (UReft r)
-> t (RType c tv (UReft r))
-> RType c tv (UReft r)
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\RType c tv (UReft r)
a RType c tv (UReft r)
b -> RType c tv (UReft r)
-> RType c tv (UReft r) -> UReft r -> RType c tv (UReft r)
forall c tv r. RType c tv r -> RType c tv r -> r -> RType c tv r
RAppTy RType c tv (UReft r)
a RType c tv (UReft r)
b UReft r
forall a. Monoid a => a
mempty) (tv -> UReft r -> RType c tv (UReft r)
forall c tv r. tv -> r -> RType c tv r
RVar tv
v UReft r
forall a. Monoid a => a
mempty) t (RType c tv (UReft r))
ts

reftUReft :: r -> UReft r
reftUReft :: forall r. r -> UReft r
reftUReft r
r    = r -> Predicate -> UReft r
forall r. r -> Predicate -> UReft r
MkUReft r
r Predicate
forall a. Monoid a => a
mempty

predUReft :: Monoid r => Predicate -> UReft r
predUReft :: forall r. Monoid r => Predicate -> UReft r
predUReft Predicate
p    = r -> Predicate -> UReft r
forall r. r -> Predicate -> UReft r
MkUReft r
forall a. Monoid a => a
dummyReft Predicate
p

dummyReft :: Monoid a => a
dummyReft :: forall a. Monoid a => a
dummyReft      = a
forall a. Monoid a => a
mempty

dummyTyId :: IsString a => a
dummyTyId :: forall a. IsString a => a
dummyTyId      = a
""

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

type BPspec = Pspec LocBareType LocSymbol

-- | The AST for a single parsed spec.
data Pspec ty ctor
  = Meas    (Measure ty ctor)                             -- ^ 'measure' definition
  | Assm    (LocSymbol, ty)                               -- ^ 'assume' signature (unchecked)
  | Asrt    (LocSymbol, ty)                               -- ^ 'assert' signature (checked)
  | LAsrt   (LocSymbol, ty)                               -- ^ 'local' assertion -- TODO RJ: what is this
  | Asrts   ([LocSymbol], (ty, Maybe [Located Expr]))     -- ^ TODO RJ: what is this
  | Impt    Symbol                                        -- ^ 'import' a specification module
  | DDecl   DataDecl                                      -- ^ refined 'data'    declaration
  | NTDecl  DataDecl                                      -- ^ refined 'newtype' declaration
  | Relational (LocSymbol, LocSymbol, ty, ty, RelExpr, RelExpr) -- ^ relational signature
  | AssmRel (LocSymbol, LocSymbol, ty, ty, RelExpr, RelExpr) -- ^ 'assume' relational signature
  | Class   (RClass ty)                                   -- ^ refined 'class' definition
  | CLaws   (RClass ty)                                   -- ^ 'class laws' definition
  | ILaws   (RILaws ty)
  | RInst   (RInstance ty)                                -- ^ refined 'instance' definition
  | Incl    FilePath                                      -- ^ 'include' a path -- TODO: deprecate
  | Invt    ty                                            -- ^ 'invariant' specification
  | Using  (ty, ty)                                       -- ^ 'using' declaration (for local invariants on a type)
  | Alias   (Located (RTAlias Symbol BareType))           -- ^ 'type' alias declaration
  | EAlias  (Located (RTAlias Symbol Expr))               -- ^ 'predicate' alias declaration
  | Embed   (LocSymbol, FTycon, TCArgs)                   -- ^ 'embed' declaration
  | Qualif  Qualifier                                     -- ^ 'qualif' definition
  | LVars   LocSymbol                                     -- ^ 'lazyvar' annotation, defer checks to *use* sites
  | Lazy    LocSymbol                                     -- ^ 'lazy' annotation, skip termination check on binder
  | Fail    LocSymbol                                     -- ^ 'fail' annotation, the binder should be unsafe
  | Rewrite LocSymbol                                     -- ^ 'rewrite' annotation, the binder generates a rewrite rule
  | Rewritewith (LocSymbol, [LocSymbol])                  -- ^ 'rewritewith' annotation, the first binder is using the rewrite rules of the second list,
  | Insts   (LocSymbol, Maybe Int)                        -- ^ 'auto-inst' or 'ple' annotation; use ple locally on binder
  | HMeas   LocSymbol                                     -- ^ 'measure' annotation; lift Haskell binder as measure
  | Reflect LocSymbol                                     -- ^ 'reflect' annotation; reflect Haskell binder as function in logic
  | Inline  LocSymbol                                     -- ^ 'inline' annotation;  inline (non-recursive) binder as an alias
  | Ignore  LocSymbol                                     -- ^ 'ignore' annotation; skip all checks inside this binder
  | ASize   LocSymbol                                     -- ^ 'autosize' annotation; automatically generate size metric for this type
  | HBound  LocSymbol                                     -- ^ 'bound' annotation; lift Haskell binder as an abstract-refinement "bound"
  | PBound  (Bound ty Expr)                               -- ^ 'bound' definition
  | Pragma  (Located String)                              -- ^ 'LIQUID' pragma, used to save configuration options in source files
  | CMeas   (Measure ty ())                               -- ^ 'class measure' definition
  | IMeas   (Measure ty ctor)                             -- ^ 'instance measure' definition
  | Varia   (LocSymbol, [Variance])                       -- ^ 'variance' annotations, marking type constructor params as co-, contra-, or in-variant
  | DSize   ([ty], LocSymbol)                             -- ^ 'data size' annotations, generating fancy termination metric
  | BFix    ()                                            -- ^ fixity annotation
  | Define  (LocSymbol, Symbol)                           -- ^ 'define' annotation for specifying aliases c.f. `include-CoreToLogic.lg`
  deriving (Typeable (Pspec ty ctor)
Typeable (Pspec ty ctor) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Pspec ty ctor -> c (Pspec ty ctor))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Pspec ty ctor))
-> (Pspec ty ctor -> Constr)
-> (Pspec ty ctor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Pspec ty ctor)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Pspec ty ctor)))
-> ((forall b. Data b => b -> b) -> Pspec ty ctor -> Pspec ty ctor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pspec ty ctor -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Pspec ty ctor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Pspec ty ctor -> m (Pspec ty ctor))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Pspec ty ctor -> m (Pspec ty ctor))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Pspec ty ctor -> m (Pspec ty ctor))
-> Data (Pspec ty ctor)
Pspec ty ctor -> Constr
Pspec ty ctor -> DataType
(forall b. Data b => b -> b) -> Pspec ty ctor -> Pspec ty ctor
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) -> Pspec ty ctor -> u
forall u. (forall d. Data d => d -> u) -> Pspec ty ctor -> [u]
forall ty ctor. (Data ctor, Data ty) => Typeable (Pspec ty ctor)
forall ty ctor. (Data ctor, Data ty) => Pspec ty ctor -> Constr
forall ty ctor. (Data ctor, Data ty) => Pspec ty ctor -> DataType
forall ty ctor.
(Data ctor, Data ty) =>
(forall b. Data b => b -> b) -> Pspec ty ctor -> Pspec ty ctor
forall ty ctor u.
(Data ctor, Data ty) =>
Int -> (forall d. Data d => d -> u) -> Pspec ty ctor -> u
forall ty ctor u.
(Data ctor, Data ty) =>
(forall d. Data d => d -> u) -> Pspec ty ctor -> [u]
forall ty ctor r r'.
(Data ctor, Data ty) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r
forall ty ctor r r'.
(Data ctor, Data ty) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r
forall ty ctor (m :: * -> *).
(Data ctor, Data ty, Monad m) =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
forall ty ctor (m :: * -> *).
(Data ctor, Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
forall ty ctor (c :: * -> *).
(Data ctor, Data ty) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pspec ty ctor)
forall ty ctor (c :: * -> *).
(Data ctor, Data ty) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pspec ty ctor -> c (Pspec ty ctor)
forall ty ctor (t :: * -> *) (c :: * -> *).
(Data ctor, Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pspec ty ctor))
forall ty ctor (t :: * -> * -> *) (c :: * -> *).
(Data ctor, Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pspec ty ctor))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pspec ty ctor)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pspec ty ctor -> c (Pspec ty ctor)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Pspec ty ctor))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pspec ty ctor))
$cgfoldl :: forall ty ctor (c :: * -> *).
(Data ctor, Data ty) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pspec ty ctor -> c (Pspec ty ctor)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pspec ty ctor -> c (Pspec ty ctor)
$cgunfold :: forall ty ctor (c :: * -> *).
(Data ctor, Data ty) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pspec ty ctor)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pspec ty ctor)
$ctoConstr :: forall ty ctor. (Data ctor, Data ty) => Pspec ty ctor -> Constr
toConstr :: Pspec ty ctor -> Constr
$cdataTypeOf :: forall ty ctor. (Data ctor, Data ty) => Pspec ty ctor -> DataType
dataTypeOf :: Pspec ty ctor -> DataType
$cdataCast1 :: forall ty ctor (t :: * -> *) (c :: * -> *).
(Data ctor, Data ty, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pspec ty ctor))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Pspec ty ctor))
$cdataCast2 :: forall ty ctor (t :: * -> * -> *) (c :: * -> *).
(Data ctor, Data ty, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pspec ty ctor))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pspec ty ctor))
$cgmapT :: forall ty ctor.
(Data ctor, Data ty) =>
(forall b. Data b => b -> b) -> Pspec ty ctor -> Pspec ty ctor
gmapT :: (forall b. Data b => b -> b) -> Pspec ty ctor -> Pspec ty ctor
$cgmapQl :: forall ty ctor r r'.
(Data ctor, Data ty) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r
$cgmapQr :: forall ty ctor r r'.
(Data ctor, Data ty) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pspec ty ctor -> r
$cgmapQ :: forall ty ctor u.
(Data ctor, Data ty) =>
(forall d. Data d => d -> u) -> Pspec ty ctor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Pspec ty ctor -> [u]
$cgmapQi :: forall ty ctor u.
(Data ctor, Data ty) =>
Int -> (forall d. Data d => d -> u) -> Pspec ty ctor -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pspec ty ctor -> u
$cgmapM :: forall ty ctor (m :: * -> *).
(Data ctor, Data ty, Monad m) =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
$cgmapMp :: forall ty ctor (m :: * -> *).
(Data ctor, Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
$cgmapMo :: forall ty ctor (m :: * -> *).
(Data ctor, Data ty, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Pspec ty ctor -> m (Pspec ty ctor)
Data, Int -> Pspec ty ctor -> ShowS
[Pspec ty ctor] -> ShowS
Pspec ty ctor -> [Char]
(Int -> Pspec ty ctor -> ShowS)
-> (Pspec ty ctor -> [Char])
-> ([Pspec ty ctor] -> ShowS)
-> Show (Pspec ty ctor)
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
forall ty ctor.
(PPrint ty, PPrint ctor, Show ty) =>
Int -> Pspec ty ctor -> ShowS
forall ty ctor.
(PPrint ty, PPrint ctor, Show ty) =>
[Pspec ty ctor] -> ShowS
forall ty ctor.
(PPrint ty, PPrint ctor, Show ty) =>
Pspec ty ctor -> [Char]
$cshowsPrec :: forall ty ctor.
(PPrint ty, PPrint ctor, Show ty) =>
Int -> Pspec ty ctor -> ShowS
showsPrec :: Int -> Pspec ty ctor -> ShowS
$cshow :: forall ty ctor.
(PPrint ty, PPrint ctor, Show ty) =>
Pspec ty ctor -> [Char]
show :: Pspec ty ctor -> [Char]
$cshowList :: forall ty ctor.
(PPrint ty, PPrint ctor, Show ty) =>
[Pspec ty ctor] -> ShowS
showList :: [Pspec ty ctor] -> ShowS
Show, Typeable)

instance (PPrint ty, PPrint ctor) => PPrint (Pspec ty ctor) where
  pprintTidy :: Tidy -> Pspec ty ctor -> Doc
pprintTidy = Tidy -> Pspec ty ctor -> Doc
forall ty ctor.
(PPrint ty, PPrint ctor) =>
Tidy -> Pspec ty ctor -> 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 -> [LocSymbol] -> t -> Maybe [Located Expr] -> PJ.Doc
ppAsserts :: forall t.
PPrint t =>
Tidy -> [LocSymbol] -> t -> Maybe [Located Expr] -> Doc
ppAsserts Tidy
k [LocSymbol]
lxs t
t Maybe [Located Expr]
mles
  = [Doc] -> Doc
PJ.hcat [ Doc -> [Doc] -> Doc
splice Doc
", " (Tidy -> Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Symbol -> Doc) -> [Symbol] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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]
lxs))
            , Doc
" :: "
            , Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
t
            , Maybe [Located Expr] -> Doc
forall {f :: * -> *} {b}.
(PPrint (f b), Functor f) =>
Maybe (f (Located b)) -> Doc
ppLes Maybe [Located Expr]
mles
            ]
  where
    ppLes :: Maybe (f (Located b)) -> Doc
ppLes Maybe (f (Located b))
Nothing    = Doc
""
    ppLes (Just f (Located b)
les) = Doc
"/" Doc -> Doc -> Doc
<+> Tidy -> f b -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (Located b -> b
forall a. Located a -> a
val (Located b -> b) -> f (Located b) -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (Located b)
les)

ppPspec :: (PPrint t, PPrint c) => Tidy -> Pspec t c -> PJ.Doc
ppPspec :: forall ty ctor.
(PPrint ty, PPrint ctor) =>
Tidy -> Pspec ty ctor -> Doc
ppPspec Tidy
k (Meas Measure t c
m)
  = Doc
"measure" Doc -> Doc -> Doc
<+> Tidy -> Measure t c -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k Measure t c
m
ppPspec Tidy
k (Assm (LocSymbol
lx, t
t))
  = Doc
"assume"  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) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
t
ppPspec Tidy
k (Asrt (LocSymbol
lx, t
t))
  = Doc
"assert"  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) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
t
ppPspec Tidy
k (LAsrt (LocSymbol
lx, t
t))
  = Doc
"local assert"  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) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
t
ppPspec Tidy
k (Asrts ([LocSymbol]
lxs, (t
t, Maybe [Located Expr]
les)))
  = Tidy -> [LocSymbol] -> t -> Maybe [Located Expr] -> Doc
forall t.
PPrint t =>
Tidy -> [LocSymbol] -> t -> Maybe [Located Expr] -> Doc
ppAsserts Tidy
k [LocSymbol]
lxs t
t Maybe [Located Expr]
les
ppPspec Tidy
k (Impt  Symbol
x)
  = Doc
"import" Doc -> Doc -> Doc
<+> Tidy -> Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k Symbol
x
ppPspec Tidy
k (DDecl DataDecl
d)
  = Tidy -> DataDecl -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k DataDecl
d
ppPspec Tidy
k (NTDecl DataDecl
d)
  = Doc
"newtype" Doc -> Doc -> Doc
<+> Tidy -> DataDecl -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k DataDecl
d
ppPspec Tidy
_ (Incl [Char]
f)
  = Doc
"include" Doc -> Doc -> Doc
<+> Doc
"<" Doc -> Doc -> Doc
PJ.<> [Char] -> Doc
PJ.text [Char]
f Doc -> Doc -> Doc
PJ.<> Doc
">"
ppPspec Tidy
k (Invt t
t)
  = Doc
"invariant" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
t
ppPspec Tidy
k (Using (t
t1, t
t2))
  = Doc
"using" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
t1 Doc -> Doc -> Doc
<+> Doc
"as" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
t2
ppPspec Tidy
k (Alias   (Loc SourcePos
_ SourcePos
_ RTAlias Symbol (RType BTyCon BTyVar RReft)
rta))
  = Doc
"type" Doc -> Doc -> Doc
<+> Tidy -> RTAlias Symbol (RType BTyCon BTyVar RReft) -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RTAlias Symbol (RType BTyCon BTyVar RReft)
rta
ppPspec Tidy
k (EAlias  (Loc SourcePos
_ SourcePos
_ RTAlias Symbol Expr
rte))
  = Doc
"predicate" Doc -> Doc -> Doc
<+> Tidy -> RTAlias Symbol Expr -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RTAlias Symbol Expr
rte
ppPspec Tidy
k (Embed   (LocSymbol
lx, FTycon
tc, TCArgs
NoArgs))
  = Doc
"embed" 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)         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   (LocSymbol
lx, FTycon
tc, TCArgs
WithArgs))
  = Doc
"embed" 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) 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  Qualifier
q)
  = Tidy -> Qualifier -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k Qualifier
q
ppPspec Tidy
k (LVars   LocSymbol
lx)
  = Doc
"lazyvar" 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 (Lazy   LocSymbol
lx)
  = Doc
"lazy" 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 (Rewrite   LocSymbol
lx)
  = Doc
"rewrite" 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 (Rewritewith (LocSymbol
lx, [LocSymbol]
lxs))
  = Doc
"rewriteWith" 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) Doc -> Doc -> Doc
<+> [Doc] -> Doc
PJ.hsep ((LocSymbol -> Doc) -> [LocSymbol] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map LocSymbol -> Doc
forall {a}. PPrint a => Located a -> Doc
go [LocSymbol]
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   LocSymbol
lx)
  = Doc
"fail" 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 (Insts   (LocSymbol
lx, Maybe Int
mbN))
  = Doc
"automatic-instances" 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) Doc -> Doc -> Doc
<+> Doc -> (Int -> Doc) -> Maybe Int -> Doc
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
"" ((Doc
"with" Doc -> Doc -> Doc
<+>) (Doc -> Doc) -> (Int -> Doc) -> Int -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tidy -> Int -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k) Maybe Int
mbN
ppPspec Tidy
k (HMeas   LocSymbol
lx)
  = Doc
"measure" 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 (Reflect LocSymbol
lx)
  = Doc
"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 (Inline  LocSymbol
lx)
  = Doc
"inline" 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 (Ignore  LocSymbol
lx)
  = Doc
"ignore" 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 (HBound  LocSymbol
lx)
  = Doc
"bound" 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 (ASize   LocSymbol
lx)
  = Doc
"autosize" 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 (PBound  Bound t Expr
bnd)
  = Tidy -> Bound t Expr -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k Bound t Expr
bnd
ppPspec Tidy
_ (Pragma  (Loc SourcePos
_ SourcePos
_ [Char]
s))
  = Doc
"LIQUID" Doc -> Doc -> Doc
<+> [Char] -> Doc
PJ.text [Char]
s
ppPspec Tidy
k (CMeas   Measure t ()
m)
  = Doc
"class measure" Doc -> Doc -> Doc
<+> Tidy -> Measure t () -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k Measure t ()
m
ppPspec Tidy
k (IMeas   Measure t c
m)
  = Doc
"instance  measure" Doc -> Doc -> Doc
<+> Tidy -> Measure t c -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k Measure t c
m
ppPspec Tidy
k (Class   RClass t
cls)
  = Tidy -> RClass t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RClass t
cls
ppPspec Tidy
k (CLaws  RClass t
cls)
  = Tidy -> RClass t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RClass t
cls
ppPspec Tidy
k (RInst   RInstance t
inst)
  = Tidy -> RInstance t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RInstance t
inst
ppPspec Tidy
k (Varia   (LocSymbol
lx, [Variance]
vs))
  = Doc
"data variance" 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) 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   ([t]
ds, LocSymbol
ss))
  = Doc
"data size" Doc -> Doc -> Doc
<+> Doc -> [Doc] -> Doc
splice Doc
" " (Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k (t -> Doc) -> [t] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [t]
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  (LocSymbol
lx, Symbol
y))
  = Doc
"define" 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) Doc -> Doc -> Doc
<+> Doc
"=" Doc -> Doc -> Doc
<+> Tidy -> Symbol -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k Symbol
y
ppPspec Tidy
_ ILaws{}
  = Doc
"TBD-INSTANCE-LAWS"
ppPspec Tidy
k (Relational (LocSymbol
lxl, LocSymbol
lxr, t
tl, t
tr, RelExpr
q, RelExpr
p))
  = Doc
"relational"
        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
lxl) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
tl Doc -> Doc -> Doc
<+> Doc
"~"
        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
lxr) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
tr Doc -> Doc -> Doc
<+> Doc
"|"
        Doc -> Doc -> Doc
<+> Tidy -> RelExpr -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RelExpr
q Doc -> Doc -> Doc
<+> Doc
"=>" Doc -> Doc -> Doc
<+> Tidy -> RelExpr -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RelExpr
p
ppPspec Tidy
k (AssmRel (LocSymbol
lxl, LocSymbol
lxr, t
tl, t
tr, RelExpr
q, RelExpr
p))
  = Doc
"assume relational"
        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
lxl) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
tl Doc -> Doc -> Doc
<+> Doc
"~"
        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
lxr) Doc -> Doc -> Doc
<+> Doc
"::" Doc -> Doc -> Doc
<+> Tidy -> t -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k t
tr Doc -> Doc -> Doc
<+> Doc
"|"
        Doc -> Doc -> Doc
<+> Tidy -> RelExpr -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RelExpr
q Doc -> Doc -> Doc
<+> Doc
"=>" Doc -> Doc -> Doc
<+> Tidy -> RelExpr -> Doc
forall a. PPrint a => Tidy -> a -> Doc
pprintTidy Tidy
k RelExpr
p


-- | For debugging
{-instance Show (Pspec a b) where
  show (Meas   _) = "Meas"
  show (Assm   _) = "Assm"
  show (Asrt   _) = "Asrt"
  show (LAsrt  _) = "LAsrt"
  show (Asrts  _) = "Asrts"
  show (Impt   _) = "Impt"
  shcl  _) = "DDecl"
  show (NTDecl _) = "NTDecl"
  show (Incl   _) = "Incl"
  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 (Insts  _) = "Insts"
  show (Reflect _) = "Reflect"
  show (HMeas  _) = "HMeas"
  show (HBound _) = "HBound"
  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"-}

qualifySpec :: Symbol -> Spec ty bndr -> Spec ty bndr
qualifySpec :: forall ty bndr. Symbol -> Spec ty bndr -> Spec ty bndr
qualifySpec Symbol
name Spec ty bndr
sp = Spec ty bndr
sp { sigs      = [ (tx x, t)  | (x, t)  <- sigs sp]
                         -- , asmSigs   = [ (tx x, t)  | (x, t)  <- asmSigs sp]
                         }
  where
    tx :: Located Symbol -> Located Symbol
    tx :: LocSymbol -> LocSymbol
tx = (Symbol -> Symbol) -> LocSymbol -> LocSymbol
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Symbol -> Symbol -> Symbol
qualifySymbol Symbol
name)

-- | 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.
--
-- Andres: It is unfortunately totally unclear to me what the justification
-- for the qualification is, and in particular, why it is being done for
-- the asserted signatures only. My trust is not exactly improved by the
-- commented out line in 'qualifySpec'.
--
mkSpec :: ModName -> [BPspec] -> (ModName, Measure.Spec LocBareType LocSymbol)
mkSpec :: ModName -> [BPspec] -> (ModName, BareSpec)
mkSpec ModName
name [BPspec]
xs         = (ModName
name,) (BareSpec -> (ModName, BareSpec))
-> BareSpec -> (ModName, BareSpec)
forall a b. (a -> b) -> a -> b
$ Symbol -> BareSpec -> BareSpec
forall ty bndr. Symbol -> Spec ty bndr -> Spec ty bndr
qualifySpec (ModName -> Symbol
forall a. Symbolic a => a -> Symbol
symbol ModName
name) Measure.Spec
  { measures :: [Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol]
Measure.measures   = [Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
m | Meas   Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
m <- [BPspec]
xs]
  , asmSigs :: [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
Measure.asmSigs    = [(LocSymbol, Located (RType BTyCon BTyVar RReft))
a | Assm   (LocSymbol, Located (RType BTyCon BTyVar RReft))
a <- [BPspec]
xs]
  , sigs :: [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
Measure.sigs       = [(LocSymbol, Located (RType BTyCon BTyVar RReft))
a | Asrt   (LocSymbol, Located (RType BTyCon BTyVar RReft))
a <- [BPspec]
xs]
                      [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
-> [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
-> [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
forall a. [a] -> [a] -> [a]
++ [(LocSymbol
y, Located (RType BTyCon BTyVar RReft)
t) | Asrts ([LocSymbol]
ys, (Located (RType BTyCon BTyVar RReft)
t, Maybe [Located Expr]
_)) <- [BPspec]
xs, LocSymbol
y <- [LocSymbol]
ys]
  , localSigs :: [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
Measure.localSigs  = []
  , reflSigs :: [(LocSymbol, Located (RType BTyCon BTyVar RReft))]
Measure.reflSigs   = []
  , impSigs :: [(Symbol, Sort)]
Measure.impSigs    = []
  , expSigs :: [(Symbol, Sort)]
Measure.expSigs    = []
  , invariants :: [(Maybe LocSymbol, Located (RType BTyCon BTyVar RReft))]
Measure.invariants = [(Maybe LocSymbol
forall a. Maybe a
Nothing, Located (RType BTyCon BTyVar RReft)
t) | Invt   Located (RType BTyCon BTyVar RReft)
t <- [BPspec]
xs]
  , ialiases :: [(Located (RType BTyCon BTyVar RReft),
  Located (RType BTyCon BTyVar RReft))]
Measure.ialiases   = [(Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft))
t | Using (Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft))
t <- [BPspec]
xs]
  , imports :: [Symbol]
Measure.imports    = [Symbol
i | Impt   Symbol
i <- [BPspec]
xs]
  , dataDecls :: [DataDecl]
Measure.dataDecls  = [DataDecl
d | DDecl  DataDecl
d <- [BPspec]
xs] [DataDecl] -> [DataDecl] -> [DataDecl]
forall a. [a] -> [a] -> [a]
++ [DataDecl
d | NTDecl DataDecl
d <- [BPspec]
xs]
  , newtyDecls :: [DataDecl]
Measure.newtyDecls = [DataDecl
d | NTDecl DataDecl
d <- [BPspec]
xs]
  , includes :: [[Char]]
Measure.includes   = [[Char]
q | Incl   [Char]
q <- [BPspec]
xs]
  , aliases :: [Located (RTAlias Symbol (RType BTyCon BTyVar RReft))]
Measure.aliases    = [Located (RTAlias Symbol (RType BTyCon BTyVar RReft))
a | Alias  Located (RTAlias Symbol (RType BTyCon BTyVar RReft))
a <- [BPspec]
xs]
  , ealiases :: [Located (RTAlias Symbol Expr)]
Measure.ealiases   = [Located (RTAlias Symbol Expr)
e | EAlias Located (RTAlias Symbol Expr)
e <- [BPspec]
xs]
  , embeds :: TCEmb LocSymbol
Measure.embeds     = [(LocSymbol, (Sort, TCArgs))] -> TCEmb LocSymbol
forall a. (Eq a, Hashable a) => [(a, (Sort, TCArgs))] -> TCEmb a
tceFromList [(LocSymbol
c, (FTycon -> Sort
fTyconSort FTycon
tc, TCArgs
a)) | Embed (LocSymbol
c, FTycon
tc, TCArgs
a) <- [BPspec]
xs]
  , qualifiers :: [Qualifier]
Measure.qualifiers = [Qualifier
q | Qualif Qualifier
q <- [BPspec]
xs]
  , lvars :: HashSet LocSymbol
Measure.lvars      = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
d | LVars LocSymbol
d  <- [BPspec]
xs]
  , autois :: HashMap LocSymbol (Maybe Int)
Measure.autois     = [(LocSymbol, Maybe Int)] -> HashMap LocSymbol (Maybe Int)
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(LocSymbol, Maybe Int)
s | Insts (LocSymbol, Maybe Int)
s <- [BPspec]
xs]
  , pragmas :: [Located [Char]]
Measure.pragmas    = [Located [Char]
s | Pragma Located [Char]
s <- [BPspec]
xs]
  , cmeasures :: [Measure (Located (RType BTyCon BTyVar RReft)) ()]
Measure.cmeasures  = [Measure (Located (RType BTyCon BTyVar RReft)) ()
m | CMeas  Measure (Located (RType BTyCon BTyVar RReft)) ()
m <- [BPspec]
xs]
  , imeasures :: [Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol]
Measure.imeasures  = [Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
m | IMeas  Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
m <- [BPspec]
xs]
  , classes :: [RClass (Located (RType BTyCon BTyVar RReft))]
Measure.classes    = [RClass (Located (RType BTyCon BTyVar RReft))
c | Class  RClass (Located (RType BTyCon BTyVar RReft))
c <- [BPspec]
xs]
  , relational :: [(LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
  Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)]
Measure.relational = [(LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
r | Relational (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
r <- [BPspec]
xs]
  , asmRel :: [(LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
  Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)]
Measure.asmRel     = [(LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
r | AssmRel (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
r <- [BPspec]
xs]
  , claws :: [RClass (Located (RType BTyCon BTyVar RReft))]
Measure.claws      = [RClass (Located (RType BTyCon BTyVar RReft))
c | CLaws  RClass (Located (RType BTyCon BTyVar RReft))
c <- [BPspec]
xs]
  , dvariance :: [(LocSymbol, [Variance])]
Measure.dvariance  = [(LocSymbol, [Variance])
v | Varia  (LocSymbol, [Variance])
v <- [BPspec]
xs]
  , dsize :: [([Located (RType BTyCon BTyVar RReft)], LocSymbol)]
Measure.dsize      = [([Located (RType BTyCon BTyVar RReft)], LocSymbol)
v | DSize  ([Located (RType BTyCon BTyVar RReft)], LocSymbol)
v <- [BPspec]
xs]
  , rinstance :: [RInstance (Located (RType BTyCon BTyVar RReft))]
Measure.rinstance  = [RInstance (Located (RType BTyCon BTyVar RReft))
i | RInst  RInstance (Located (RType BTyCon BTyVar RReft))
i <- [BPspec]
xs]
  , ilaws :: [RILaws (Located (RType BTyCon BTyVar RReft))]
Measure.ilaws      = [RILaws (Located (RType BTyCon BTyVar RReft))
i | ILaws  RILaws (Located (RType BTyCon BTyVar RReft))
i <- [BPspec]
xs]
  , termexprs :: [(LocSymbol, [Located Expr])]
Measure.termexprs  = [(LocSymbol
y, [Located Expr]
es) | Asrts ([LocSymbol]
ys, (Located (RType BTyCon BTyVar RReft)
_, Just [Located Expr]
es)) <- [BPspec]
xs, LocSymbol
y <- [LocSymbol]
ys]
  , lazy :: HashSet LocSymbol
Measure.lazy       = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | Lazy   LocSymbol
s <- [BPspec]
xs]
  , fails :: HashSet LocSymbol
Measure.fails      = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | Fail   LocSymbol
s <- [BPspec]
xs]
  , rewrites :: HashSet LocSymbol
Measure.rewrites   = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | Rewrite LocSymbol
s <- [BPspec]
xs]
  , rewriteWith :: HashMap LocSymbol [LocSymbol]
Measure.rewriteWith = [(LocSymbol, [LocSymbol])] -> HashMap LocSymbol [LocSymbol]
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(LocSymbol, [LocSymbol])
s | Rewritewith (LocSymbol, [LocSymbol])
s <- [BPspec]
xs]
  , bounds :: RRBEnv (Located (RType BTyCon BTyVar RReft))
Measure.bounds     = [(LocSymbol, Bound (Located (RType BTyCon BTyVar RReft)) Expr)]
-> RRBEnv (Located (RType BTyCon BTyVar RReft))
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(Bound (Located (RType BTyCon BTyVar RReft)) Expr -> LocSymbol
forall t e. Bound t e -> LocSymbol
bname Bound (Located (RType BTyCon BTyVar RReft)) Expr
i, Bound (Located (RType BTyCon BTyVar RReft)) Expr
i) | PBound Bound (Located (RType BTyCon BTyVar RReft)) Expr
i <- [BPspec]
xs]
  , reflects :: HashSet LocSymbol
Measure.reflects   = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | Reflect LocSymbol
s <- [BPspec]
xs]
  , hmeas :: HashSet LocSymbol
Measure.hmeas      = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | HMeas  LocSymbol
s <- [BPspec]
xs]
  , inlines :: HashSet LocSymbol
Measure.inlines    = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | Inline LocSymbol
s <- [BPspec]
xs]
  , ignores :: HashSet LocSymbol
Measure.ignores    = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | Ignore LocSymbol
s <- [BPspec]
xs]
  , autosize :: HashSet LocSymbol
Measure.autosize   = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | ASize  LocSymbol
s <- [BPspec]
xs]
  , hbounds :: HashSet LocSymbol
Measure.hbounds    = [LocSymbol] -> HashSet LocSymbol
forall a. (Eq a, Hashable a) => [a] -> HashSet a
S.fromList [LocSymbol
s | HBound LocSymbol
s <- [BPspec]
xs]
  , defs :: HashMap LocSymbol Symbol
Measure.defs       = [(LocSymbol, Symbol)] -> HashMap LocSymbol Symbol
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(LocSymbol, Symbol)
d | Define (LocSymbol, Symbol)
d <- [BPspec]
xs]
  , axeqs :: [Equation]
Measure.axeqs      = []
  }

-- | Parse a single top level liquid specification
specP :: Parser BPspec
specP :: Parser BPspec
specP
  =     [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"assume"
    (([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"relational" StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>  ((LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
  Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
 -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
      Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
-> BPspec
forall ty ctor.
(LocSymbol, LocSymbol, ty, ty, RelExpr, RelExpr) -> Pspec ty ctor
AssmRel StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
   Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
relationalP)
        Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>                           ((LocSymbol, Located (RType BTyCon BTyVar RReft)) -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, Located (RType BTyCon BTyVar RReft))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, Located (RType BTyCon BTyVar RReft)) -> BPspec
forall ty ctor. (LocSymbol, ty) -> Pspec ty ctor
Assm   StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
tyBindP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"assert"      (((LocSymbol, Located (RType BTyCon BTyVar RReft)) -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, Located (RType BTyCon BTyVar RReft))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, Located (RType BTyCon BTyVar RReft)) -> BPspec
forall ty ctor. (LocSymbol, ty) -> Pspec ty ctor
Asrt    StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
tyBindP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"autosize"    ((LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
ASize   StateT PState (Parsec Void [Char]) LocSymbol
asizeP   )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"local"         StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((LocSymbol, Located (RType BTyCon BTyVar RReft)) -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, Located (RType BTyCon BTyVar RReft))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, Located (RType BTyCon BTyVar RReft)) -> BPspec
forall ty ctor. (LocSymbol, ty) -> Pspec ty ctor
LAsrt   StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
tyBindP  )

    -- TODO: These next two are synonyms, kill one
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"axiomatize"  ((LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
Reflect StateT PState (Parsec Void [Char]) LocSymbol
axiomP   )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"reflect"     ((LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
Reflect StateT PState (Parsec Void [Char]) LocSymbol
axiomP   )

    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"measure"    Parser BPspec
hmeasureP

    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"define"      (((LocSymbol, Symbol) -> BPspec)
-> Parser (LocSymbol, Symbol) -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, Symbol) -> BPspec
forall ty ctor. (LocSymbol, Symbol) -> Pspec ty ctor
Define  Parser (LocSymbol, Symbol)
defineP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"infixl"        StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (() -> BPspec)
-> StateT PState (Parsec Void [Char]) () -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap () -> BPspec
forall ty ctor. () -> Pspec ty ctor
BFix    StateT PState (Parsec Void [Char]) ()
infixlP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"infixr"        StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (() -> BPspec)
-> StateT PState (Parsec Void [Char]) () -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap () -> BPspec
forall ty ctor. () -> Pspec ty ctor
BFix    StateT PState (Parsec Void [Char]) ()
infixrP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"infix"         StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (() -> BPspec)
-> StateT PState (Parsec Void [Char]) () -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap () -> BPspec
forall ty ctor. () -> Pspec ty ctor
BFix    StateT PState (Parsec Void [Char]) ()
infixP   )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"inline"      ((LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
Inline  StateT PState (Parsec Void [Char]) LocSymbol
inlineP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"ignore"      ((LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
Ignore  StateT PState (Parsec Void [Char]) LocSymbol
inlineP  )

    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"bound"       ((Bound (Located (RType BTyCon BTyVar RReft)) Expr -> BPspec)
-> Parser (Bound (Located (RType BTyCon BTyVar RReft)) Expr)
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bound (Located (RType BTyCon BTyVar RReft)) Expr -> BPspec
forall ty ctor. Bound ty Expr -> Pspec ty ctor
PBound  Parser (Bound (Located (RType BTyCon BTyVar RReft)) Expr)
boundP
                                 Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
HBound  StateT PState (Parsec Void [Char]) LocSymbol
hboundP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"class"
         StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"measure"  StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Measure (Located (RType BTyCon BTyVar RReft)) () -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (Measure (Located (RType BTyCon BTyVar RReft)) ())
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Measure (Located (RType BTyCon BTyVar RReft)) () -> BPspec
forall ty ctor. Measure ty () -> Pspec ty ctor
CMeas  StateT
  PState
  (Parsec Void [Char])
  (Measure (Located (RType BTyCon BTyVar RReft)) ())
cMeasureP )
         Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"laws"     StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (RClass (Located (RType BTyCon BTyVar RReft)) -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (RClass (Located (RType BTyCon BTyVar RReft)))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RClass (Located (RType BTyCon BTyVar RReft)) -> BPspec
forall ty ctor. RClass ty -> Pspec ty ctor
CLaws  StateT
  PState
  (Parsec Void [Char])
  (RClass (Located (RType BTyCon BTyVar RReft)))
classP)
         Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (RClass (Located (RType BTyCon BTyVar RReft)) -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (RClass (Located (RType BTyCon BTyVar RReft)))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RClass (Located (RType BTyCon BTyVar RReft)) -> BPspec
forall ty ctor. RClass ty -> Pspec ty ctor
Class  StateT
  PState
  (Parsec Void [Char])
  (RClass (Located (RType BTyCon BTyVar RReft)))
classP                            ))
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"instance"
         StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"measure"  StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol)
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol -> BPspec
forall ty ctor. Measure ty ctor -> Pspec ty ctor
IMeas  StateT
  PState
  (Parsec Void [Char])
  (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol)
iMeasureP )
         Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"laws"     StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (RILaws (Located (RType BTyCon BTyVar RReft)) -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (RILaws (Located (RType BTyCon BTyVar RReft)))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RILaws (Located (RType BTyCon BTyVar RReft)) -> BPspec
forall ty ctor. RILaws ty -> Pspec ty ctor
ILaws StateT
  PState
  (Parsec Void [Char])
  (RILaws (Located (RType BTyCon BTyVar RReft)))
instanceLawP)
         Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (RInstance (Located (RType BTyCon BTyVar RReft)) -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (RInstance (Located (RType BTyCon BTyVar RReft)))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RInstance (Located (RType BTyCon BTyVar RReft)) -> BPspec
forall ty ctor. RInstance ty -> Pspec ty ctor
RInst  StateT
  PState
  (Parsec Void [Char])
  (RInstance (Located (RType BTyCon BTyVar RReft)))
instanceP ))

    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"import"        StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Symbol -> BPspec) -> Parser Symbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Symbol -> BPspec
forall ty ctor. Symbol -> Pspec ty ctor
Impt   Parser Symbol
symbolP   )

    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"data"
        StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"variance"  StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((LocSymbol, [Variance]) -> BPspec)
-> StateT PState (Parsec Void [Char]) (LocSymbol, [Variance])
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, [Variance]) -> BPspec
forall ty ctor. (LocSymbol, [Variance]) -> Pspec ty ctor
Varia  StateT PState (Parsec Void [Char]) (LocSymbol, [Variance])
datavarianceP)
        Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"size"      StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (([Located (RType BTyCon BTyVar RReft)], LocSymbol) -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     ([Located (RType BTyCon BTyVar RReft)], LocSymbol)
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Located (RType BTyCon BTyVar RReft)], LocSymbol) -> BPspec
forall ty ctor. ([ty], LocSymbol) -> Pspec ty ctor
DSize  StateT
  PState
  (Parsec Void [Char])
  ([Located (RType BTyCon BTyVar RReft)], LocSymbol)
dsizeP)
        Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (DataDecl -> BPspec)
-> StateT PState (Parsec Void [Char]) DataDecl -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DataDecl -> BPspec
forall ty ctor. DataDecl -> Pspec ty ctor
DDecl  StateT PState (Parsec Void [Char]) DataDecl
dataDeclP ))
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"newtype"       StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DataDecl -> BPspec)
-> StateT PState (Parsec Void [Char]) DataDecl -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DataDecl -> BPspec
forall ty ctor. DataDecl -> Pspec ty ctor
NTDecl StateT PState (Parsec Void [Char]) DataDecl
dataDeclP )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"relational"    StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
  Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
 -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
      Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
-> BPspec
forall ty ctor.
(LocSymbol, LocSymbol, ty, ty, RelExpr, RelExpr) -> Pspec ty ctor
Relational StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
   Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
relationalP )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"include"       StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char] -> BPspec)
-> StateT PState (Parsec Void [Char]) [Char] -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Char] -> BPspec
forall ty ctor. [Char] -> Pspec ty ctor
Incl   StateT PState (Parsec Void [Char]) [Char]
filePathP )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"invariant"   ((Located (RType BTyCon BTyVar RReft) -> BPspec)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located (RType BTyCon BTyVar RReft) -> BPspec
forall ty ctor. ty -> Pspec ty ctor
Invt   StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
invariantP)
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"using"          StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Located (RType BTyCon BTyVar RReft),
  Located (RType BTyCon BTyVar RReft))
 -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (Located (RType BTyCon BTyVar RReft),
      Located (RType BTyCon BTyVar RReft))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft))
-> BPspec
forall ty ctor. (ty, ty) -> Pspec ty ctor
Using StateT
  PState
  (Parsec Void [Char])
  (Located (RType BTyCon BTyVar RReft),
   Located (RType BTyCon BTyVar RReft))
invaliasP )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"type"          StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located (RTAlias Symbol (RType BTyCon BTyVar RReft)) -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     (Located (RTAlias Symbol (RType BTyCon BTyVar RReft)))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located (RTAlias Symbol (RType BTyCon BTyVar RReft)) -> BPspec
forall ty ctor.
Located (RTAlias Symbol (RType BTyCon BTyVar RReft))
-> Pspec ty ctor
Alias  StateT
  PState
  (Parsec Void [Char])
  (Located (RTAlias Symbol (RType BTyCon BTyVar RReft)))
aliasP    )

    -- TODO: Next two are basically synonyms
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"predicate"   ((Located (RTAlias Symbol Expr) -> BPspec)
-> StateT
     PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located (RTAlias Symbol Expr) -> BPspec
forall ty ctor. Located (RTAlias Symbol Expr) -> Pspec ty ctor
EAlias StateT PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
ealiasP   )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"expression"  ((Located (RTAlias Symbol Expr) -> BPspec)
-> StateT
     PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located (RTAlias Symbol Expr) -> BPspec
forall ty ctor. Located (RTAlias Symbol Expr) -> Pspec ty ctor
EAlias StateT PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
ealiasP   )

    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"embed"       (((LocSymbol, FTycon, TCArgs) -> BPspec)
-> StateT PState (Parsec Void [Char]) (LocSymbol, FTycon, TCArgs)
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, FTycon, TCArgs) -> BPspec
forall ty ctor. (LocSymbol, FTycon, TCArgs) -> Pspec ty ctor
Embed  StateT PState (Parsec Void [Char]) (LocSymbol, FTycon, TCArgs)
embedP    )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Char] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
"qualif"      ((Qualifier -> BPspec)
-> StateT PState (Parsec Void [Char]) Qualifier -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Qualifier -> BPspec
forall ty ctor. Qualifier -> Pspec ty ctor
Qualif (Parser Sort -> StateT PState (Parsec Void [Char]) Qualifier
qualifierP Parser Sort
sortP))
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"lazyvar"       StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
LVars  StateT PState (Parsec Void [Char]) LocSymbol
lazyVarP  )

    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"lazy"          StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
Lazy   StateT PState (Parsec Void [Char]) LocSymbol
lazyVarP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"rewrite"       StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
Rewrite   StateT PState (Parsec Void [Char]) LocSymbol
rewriteVarP )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"rewriteWith"   StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((LocSymbol, [LocSymbol]) -> BPspec)
-> StateT PState (Parsec Void [Char]) (LocSymbol, [LocSymbol])
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, [LocSymbol]) -> BPspec
forall ty ctor. (LocSymbol, [LocSymbol]) -> Pspec ty ctor
Rewritewith   StateT PState (Parsec Void [Char]) (LocSymbol, [LocSymbol])
rewriteWithP )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"fail"          StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (LocSymbol -> BPspec)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
Fail   StateT PState (Parsec Void [Char]) LocSymbol
failVarP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"ple"           StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((LocSymbol, Maybe Int) -> BPspec)
-> StateT PState (Parsec Void [Char]) (LocSymbol, Maybe Int)
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, Maybe Int) -> BPspec
forall ty ctor. (LocSymbol, Maybe Int) -> Pspec ty ctor
Insts StateT PState (Parsec Void [Char]) (LocSymbol, Maybe Int)
autoinstP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"automatic-instances" StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((LocSymbol, Maybe Int) -> BPspec)
-> StateT PState (Parsec Void [Char]) (LocSymbol, Maybe Int)
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LocSymbol, Maybe Int) -> BPspec
forall ty ctor. (LocSymbol, Maybe Int) -> Pspec ty ctor
Insts StateT PState (Parsec Void [Char]) (LocSymbol, Maybe Int)
autoinstP  )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"LIQUID"        StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located [Char] -> BPspec)
-> StateT PState (Parsec Void [Char]) (Located [Char])
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located [Char] -> BPspec
forall ty ctor. Located [Char] -> Pspec ty ctor
Pragma StateT PState (Parsec Void [Char]) (Located [Char])
pragmaP   )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"liquid"        StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Located [Char] -> BPspec)
-> StateT PState (Parsec Void [Char]) (Located [Char])
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located [Char] -> BPspec
forall ty ctor. Located [Char] -> Pspec ty ctor
Pragma StateT PState (Parsec Void [Char]) (Located [Char])
pragmaP   )
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> {- DEFAULT -}                (([LocSymbol],
  (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
 -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     ([LocSymbol],
      (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([LocSymbol],
 (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
-> BPspec
forall ty ctor.
([LocSymbol], (ty, Maybe [Located Expr])) -> Pspec ty ctor
Asrts  StateT
  PState
  (Parsec Void [Char])
  ([LocSymbol],
   (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
tyBindsP
    Parser BPspec -> [Char] -> Parser 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] -> Parser BPspec -> Parser BPspec
fallbackSpecP [Char]
kw Parser BPspec
p = do
  (Loc SourcePos
l1 SourcePos
l2 [Char]
_) <- [Char] -> StateT PState (Parsec Void [Char]) (Located [Char])
locReserved [Char]
kw
  Parser BPspec
p Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (([LocSymbol],
  (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
 -> BPspec)
-> StateT
     PState
     (Parsec Void [Char])
     ([LocSymbol],
      (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
-> Parser BPspec
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([LocSymbol],
 (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
-> BPspec
forall ty ctor.
([LocSymbol], (ty, Maybe [Located Expr])) -> Pspec ty ctor
Asrts (LocSymbol
-> StateT
     PState
     (Parsec Void [Char])
     ([LocSymbol],
      (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
tyBindsRemP (SourcePos -> SourcePos -> Symbol -> LocSymbol
forall a. SourcePos -> SourcePos -> a -> Located a
Loc SourcePos
l1 SourcePos
l2 ([Char] -> Symbol
forall a. Symbolic a => a -> Symbol
symbol [Char]
kw)) )

-- | Same as tyBindsP, except the single initial symbol has already been matched
tyBindsRemP :: LocSymbol -> Parser ([LocSymbol], (Located BareType, Maybe [Located Expr]))
tyBindsRemP :: LocSymbol
-> StateT
     PState
     (Parsec Void [Char])
     ([LocSymbol],
      (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
tyBindsRemP LocSymbol
sym = do
  [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"::"
  (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
tb <- Parser (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
termBareTypeP
  ([LocSymbol],
 (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
-> StateT
     PState
     (Parsec Void [Char])
     ([LocSymbol],
      (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([LocSymbol
sym],(Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
tb)

pragmaP :: Parser (Located String)
pragmaP :: StateT PState (Parsec Void [Char]) (Located [Char])
pragmaP = StateT PState (Parsec Void [Char]) (Located [Char])
locStringLiteral

autoinstP :: Parser (LocSymbol, Maybe Int)
autoinstP :: StateT PState (Parsec Void [Char]) (LocSymbol, Maybe Int)
autoinstP = do LocSymbol
x <- StateT PState (Parsec Void [Char]) LocSymbol
locBinderP
               Maybe Integer
i <- StateT PState (Parsec Void [Char]) Integer
-> StateT PState (Parsec Void [Char]) (Maybe Integer)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"with" StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) Integer
-> StateT PState (Parsec Void [Char]) Integer
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT PState (Parsec Void [Char]) Integer
natural)
               (LocSymbol, Maybe Int)
-> StateT PState (Parsec Void [Char]) (LocSymbol, Maybe Int)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (LocSymbol
x, Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Int) -> Maybe Integer -> Maybe Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Integer
i)

lazyVarP :: Parser LocSymbol
lazyVarP :: StateT PState (Parsec Void [Char]) LocSymbol
lazyVarP = StateT PState (Parsec Void [Char]) LocSymbol
locBinderP


rewriteVarP :: Parser LocSymbol
rewriteVarP :: StateT PState (Parsec Void [Char]) LocSymbol
rewriteVarP = StateT PState (Parsec Void [Char]) LocSymbol
locBinderP

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

failVarP :: Parser LocSymbol
failVarP :: StateT PState (Parsec Void [Char]) LocSymbol
failVarP = StateT PState (Parsec Void [Char]) LocSymbol
locBinderP

axiomP :: Parser LocSymbol
axiomP :: StateT PState (Parsec Void [Char]) LocSymbol
axiomP = StateT PState (Parsec Void [Char]) LocSymbol
locBinderP

hboundP :: Parser LocSymbol
hboundP :: StateT PState (Parsec Void [Char]) LocSymbol
hboundP = StateT PState (Parsec Void [Char]) LocSymbol
locBinderP

inlineP :: Parser LocSymbol
inlineP :: StateT PState (Parsec Void [Char]) LocSymbol
inlineP = StateT PState (Parsec Void [Char]) LocSymbol
locBinderP

asizeP :: Parser LocSymbol
asizeP :: StateT PState (Parsec Void [Char]) LocSymbol
asizeP = StateT PState (Parsec Void [Char]) LocSymbol
locBinderP

filePathP     :: Parser FilePath
filePathP :: StateT PState (Parsec Void [Char]) [Char]
filePathP     = StateT PState (Parsec Void [Char]) [Char]
-> StateT PState (Parsec Void [Char]) [Char]
forall a. Parser a -> Parser a
angles (StateT PState (Parsec Void [Char]) [Char]
 -> StateT PState (Parsec Void [Char]) [Char])
-> StateT PState (Parsec Void [Char]) [Char]
-> StateT PState (Parsec Void [Char]) [Char]
forall a b. (a -> b) -> a -> b
$ StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) [Char]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some StateT PState (Parsec Void [Char]) Char
pathCharP
  where
    pathCharP :: Parser Char
    pathCharP :: StateT PState (Parsec Void [Char]) Char
pathCharP = [StateT PState (Parsec Void [Char]) Char]
-> StateT PState (Parsec Void [Char]) Char
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice ([StateT PState (Parsec Void [Char]) Char]
 -> StateT PState (Parsec Void [Char]) Char)
-> [StateT PState (Parsec Void [Char]) Char]
-> StateT PState (Parsec Void [Char]) Char
forall a b. (a -> b) -> a -> b
$ Char -> StateT PState (Parsec Void [Char]) Char
Token [Char] -> StateT PState (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char (Char -> StateT PState (Parsec Void [Char]) Char)
-> [Char] -> [StateT PState (Parsec Void [Char]) Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char]
pathChars

    pathChars :: [Char]
    pathChars :: [Char]
pathChars = [Char
'a'..Char
'z'] [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'A'..Char
'Z'] [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'0'..Char
'9'] [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'.', Char
'/']

datavarianceP :: Parser (Located Symbol, [Variance])
datavarianceP :: StateT PState (Parsec Void [Char]) (LocSymbol, [Variance])
datavarianceP = (LocSymbol -> [Variance] -> (LocSymbol, [Variance]))
-> StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) [Variance]
-> StateT PState (Parsec Void [Char]) (LocSymbol, [Variance])
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) StateT PState (Parsec Void [Char]) LocSymbol
locUpperIdP (StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) [Variance]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many StateT PState (Parsec Void [Char]) Variance
varianceP)

dsizeP :: Parser ([Located BareType], Located Symbol)
dsizeP :: StateT
  PState
  (Parsec Void [Char])
  ([Located (RType BTyCon BTyVar RReft)], LocSymbol)
dsizeP = ([Located (RType BTyCon BTyVar RReft)]
 -> LocSymbol -> ([Located (RType BTyCon BTyVar RReft)], LocSymbol))
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT PState (Parsec Void [Char]) LocSymbol
-> StateT
     PState
     (Parsec Void [Char])
     ([Located (RType BTyCon BTyVar RReft)], LocSymbol)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) (StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall a. Parser a -> Parser a
parens (StateT
   PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
 -> StateT
      PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)])
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall a b. (a -> b) -> a -> b
$ StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) [Char]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
genBareTypeP) StateT PState (Parsec Void [Char]) [Char]
comma) StateT PState (Parsec Void [Char]) LocSymbol
locBinderP


varianceP :: Parser Variance
varianceP :: StateT PState (Parsec Void [Char]) Variance
varianceP = ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"bivariant"     StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Variance -> StateT PState (Parsec Void [Char]) Variance
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Variance
Bivariant)
        StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"invariant"     StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Variance -> StateT PState (Parsec Void [Char]) Variance
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Variance
Invariant)
        StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"covariant"     StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Variance -> StateT PState (Parsec Void [Char]) Variance
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Variance
Covariant)
        StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"contravariant" StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) Variance
-> StateT PState (Parsec Void [Char]) Variance
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Variance -> StateT PState (Parsec Void [Char]) Variance
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Variance
Contravariant)
        StateT PState (Parsec Void [Char]) Variance
-> [Char] -> StateT PState (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 ([LocSymbol], (Located BareType, Maybe [Located Expr]))
tyBindsP :: StateT
  PState
  (Parsec Void [Char])
  ([LocSymbol],
   (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
tyBindsP =
  StateT PState (Parsec Void [Char]) [LocSymbol]
-> StateT PState (Parsec Void [Char]) ()
-> Parser
     (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
-> StateT
     PState
     (Parsec Void [Char])
     ([LocSymbol],
      (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr]))
forall x a y. Parser x -> Parser a -> Parser y -> Parser (x, y)
xyP (StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) [Char]
-> StateT PState (Parsec Void [Char]) [LocSymbol]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy1 StateT PState (Parsec Void [Char]) LocSymbol
locBinderP StateT PState (Parsec Void [Char]) [Char]
comma) ([Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"::") Parser (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
termBareTypeP

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

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

termBareTypeP :: Parser (Located BareType, Maybe [Located Expr])
termBareTypeP :: Parser (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
termBareTypeP = do
  Located (RType BTyCon BTyVar RReft)
t <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
genBareTypeP
  Located (RType BTyCon BTyVar RReft)
-> Parser
     (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
termTypeP Located (RType BTyCon BTyVar RReft)
t Parser (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
-> Parser
     (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
-> Parser
     (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
-> Parser
     (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Located (RType BTyCon BTyVar RReft)
t, Maybe [Located Expr]
forall a. Maybe a
Nothing)

termTypeP :: Located BareType ->Parser (Located BareType, Maybe [Located Expr])
termTypeP :: Located (RType BTyCon BTyVar RReft)
-> Parser
     (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
termTypeP Located (RType BTyCon BTyVar RReft)
t
  = do
       [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"/"
       [Located Expr]
es <- Parser [Located Expr] -> Parser [Located Expr]
forall a. Parser a -> Parser a
brackets (Parser [Located Expr] -> Parser [Located Expr])
-> Parser [Located Expr] -> Parser [Located Expr]
forall a b. (a -> b) -> a -> b
$ StateT PState (Parsec Void [Char]) (Located Expr)
-> StateT PState (Parsec Void [Char]) [Char]
-> Parser [Located Expr]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy (Parser Expr -> StateT PState (Parsec Void [Char]) (Located Expr)
forall a. Parser a -> Parser (Located a)
located Parser Expr
exprP) StateT PState (Parsec Void [Char]) [Char]
comma
       (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
-> Parser
     (Located (RType BTyCon BTyVar RReft), Maybe [Located Expr])
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Located (RType BTyCon BTyVar RReft)
t, [Located Expr] -> Maybe [Located Expr]
forall a. a -> Maybe a
Just [Located Expr]
es)

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

invariantP :: Parser (Located BareType)
invariantP :: StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
invariantP = StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
genBareTypeP

invaliasP :: Parser (Located BareType, Located BareType)
invaliasP :: StateT
  PState
  (Parsec Void [Char])
  (Located (RType BTyCon BTyVar RReft),
   Located (RType BTyCon BTyVar RReft))
invaliasP
  = do Located (RType BTyCon BTyVar RReft)
t  <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
genBareTypeP
       [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"as"
       Located (RType BTyCon BTyVar RReft)
ta <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
genBareTypeP
       (Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (Located (RType BTyCon BTyVar RReft),
      Located (RType BTyCon BTyVar RReft))
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Located (RType BTyCon BTyVar RReft)
t, Located (RType BTyCon BTyVar RReft)
ta)

genBareTypeP :: Parser BareType
genBareTypeP :: StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
genBareTypeP = StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP

embedP :: Parser (Located Symbol, FTycon, TCArgs)
embedP :: StateT PState (Parsec Void [Char]) (LocSymbol, FTycon, TCArgs)
embedP = do
  LocSymbol
x <- StateT PState (Parsec Void [Char]) LocSymbol
locUpperIdP
  TCArgs
a <- StateT PState (Parsec Void [Char]) TCArgs
-> StateT PState (Parsec Void [Char]) TCArgs
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"*" StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) TCArgs
-> StateT PState (Parsec Void [Char]) TCArgs
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TCArgs -> StateT PState (Parsec Void [Char]) TCArgs
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return TCArgs
WithArgs) StateT PState (Parsec Void [Char]) TCArgs
-> StateT PState (Parsec Void [Char]) TCArgs
-> StateT PState (Parsec Void [Char]) TCArgs
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TCArgs -> StateT PState (Parsec Void [Char]) TCArgs
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return TCArgs
NoArgs -- TODO: reserved "*" looks suspicious
  ()
_ <- [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"as"
  FTycon
t <- Parser FTycon
fTyConP
  (LocSymbol, FTycon, TCArgs)
-> StateT PState (Parsec Void [Char]) (LocSymbol, FTycon, TCArgs)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (LocSymbol
x, FTycon
t, TCArgs
a)
  --  = xyP locUpperIdP symbolTCArgs (reserved "as") fTyConP


aliasP :: Parser (Located (RTAlias Symbol BareType))
aliasP :: StateT
  PState
  (Parsec Void [Char])
  (Located (RTAlias Symbol (RType BTyCon BTyVar RReft)))
aliasP  = (Symbol -> Symbol)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState
     (Parsec Void [Char])
     (Located (RTAlias Symbol (RType BTyCon BTyVar RReft)))
forall tv ty.
(Symbol -> tv) -> Parser ty -> Parser (Located (RTAlias tv ty))
rtAliasP Symbol -> Symbol
forall a. a -> a
id     StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP StateT
  PState
  (Parsec Void [Char])
  (Located (RTAlias Symbol (RType BTyCon BTyVar RReft)))
-> [Char]
-> StateT
     PState
     (Parsec Void [Char])
     (Located (RTAlias Symbol (RType BTyCon BTyVar RReft)))
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"aliasP"

ealiasP :: Parser (Located (RTAlias Symbol Expr))
ealiasP :: StateT PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
ealiasP = StateT PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
-> StateT
     PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ((Symbol -> Symbol)
-> Parser Expr
-> StateT
     PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
forall tv ty.
(Symbol -> tv) -> Parser ty -> Parser (Located (RTAlias tv ty))
rtAliasP Symbol -> Symbol
forall a. Symbolic a => a -> Symbol
symbol Parser Expr
predP)
      StateT PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
-> StateT
     PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
-> StateT
     PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Symbol -> Symbol)
-> Parser Expr
-> StateT
     PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
forall tv ty.
(Symbol -> tv) -> Parser ty -> Parser (Located (RTAlias tv ty))
rtAliasP Symbol -> Symbol
forall a. Symbolic a => a -> Symbol
symbol Parser Expr
exprP
      StateT PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
-> [Char]
-> StateT
     PState (Parsec Void [Char]) (Located (RTAlias Symbol Expr))
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 SourcePos
pos  <- StateT PState (Parsec Void [Char]) SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
       Symbol
name <- Parser Symbol
upperIdP
       [Symbol]
args <- Parser Symbol -> StateT PState (Parsec Void [Char]) [Symbol]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many Parser Symbol
aliasIdP
       [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"="
       ty
body <- Parser ty
bodyP
       SourcePos
posE <- StateT PState (Parsec Void [Char]) SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
       let ([Symbol]
tArgs, [Symbol]
vArgs) = (Symbol -> Bool) -> [Symbol] -> ([Symbol], [Symbol])
forall a. (a -> Bool) -> [a] -> ([a], [a])
partition (Char -> Bool
isSmall (Char -> Bool) -> (Symbol -> Char) -> Symbol -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Symbol -> Char
headSym) [Symbol]
args
       Located (RTAlias tv ty) -> Parser (Located (RTAlias tv ty))
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Located (RTAlias tv ty) -> Parser (Located (RTAlias tv ty)))
-> Located (RTAlias tv ty) -> Parser (Located (RTAlias tv ty))
forall a b. (a -> b) -> a -> b
$ SourcePos -> SourcePos -> RTAlias tv ty -> Located (RTAlias tv ty)
forall a. SourcePos -> SourcePos -> a -> Located a
Loc SourcePos
pos SourcePos
posE (Symbol -> [tv] -> [Symbol] -> ty -> RTAlias tv ty
forall x a. Symbol -> [x] -> [Symbol] -> a -> RTAlias x a
RTA Symbol
name (Symbol -> tv
f (Symbol -> tv) -> [Symbol] -> [tv]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol]
tArgs) [Symbol]
vArgs ty
body)

hmeasureP :: Parser BPspec
hmeasureP :: Parser BPspec
hmeasureP = do
  StateT PState (Parsec Void [Char]) ()
setLayout
  LocSymbol
b <- StateT PState (Parsec Void [Char]) LocSymbol
locBinderP
  (do [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"::"
      Located (RType BTyCon BTyVar RReft)
ty <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
genBareTypeP
      StateT PState (Parsec Void [Char]) ()
popLayout StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) ()
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT PState (Parsec Void [Char]) ()
popLayout
      [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
eqns <- Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
-> Parser [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
forall a. Parser a -> Parser [a]
block (Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
 -> Parser [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol])
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
-> Parser [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
forall a b. (a -> b) -> a -> b
$ Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
 -> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol))
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
forall a b. (a -> b) -> a -> b
$ Parser Body
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
measureDefP (Parser Body
rawBodyP Parser Body -> Parser Body -> Parser Body
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Located (RType BTyCon BTyVar RReft) -> Parser Body
tyBodyP Located (RType BTyCon BTyVar RReft)
ty)
      BPspec -> Parser BPspec
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol -> BPspec
forall ty ctor. Measure ty ctor -> Pspec ty ctor
Meas (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol -> BPspec)
-> Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
-> BPspec
forall a b. (a -> b) -> a -> b
$ LocSymbol
-> Located (RType BTyCon BTyVar RReft)
-> [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
-> MeasureKind
-> UnSortedExprs
-> Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
forall ty bndr.
LocSymbol
-> ty
-> [Def ty bndr]
-> MeasureKind
-> UnSortedExprs
-> Measure ty bndr
Measure.mkM LocSymbol
b Located (RType BTyCon BTyVar RReft)
ty [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
eqns MeasureKind
MsMeasure UnSortedExprs
forall a. Monoid a => a
mempty))
    Parser BPspec -> Parser BPspec -> Parser BPspec
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (StateT PState (Parsec Void [Char]) ()
popLayout StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) ()
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT PState (Parsec Void [Char]) ()
popLayout StateT PState (Parsec Void [Char]) ()
-> Parser BPspec -> Parser BPspec
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> BPspec -> Parser BPspec
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (LocSymbol -> BPspec
forall ty ctor. LocSymbol -> Pspec ty ctor
HMeas LocSymbol
b))

measureP :: Parser (Measure (Located BareType) LocSymbol)
measureP :: StateT
  PState
  (Parsec Void [Char])
  (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol)
measureP = do
  (LocSymbol
x, Located (RType BTyCon BTyVar RReft)
ty) <- StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
indentedLine StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
tyBindP
  Maybe [Char]
_ <- StateT PState (Parsec Void [Char]) [Char]
-> StateT PState (Parsec Void [Char]) (Maybe [Char])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional StateT PState (Parsec Void [Char]) [Char]
semi
  [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
eqns    <- Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
-> Parser [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
forall a. Parser a -> Parser [a]
block (Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
 -> Parser [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol])
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
-> Parser [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
forall a b. (a -> b) -> a -> b
$ Parser Body
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
measureDefP (Parser Body
rawBodyP Parser Body -> Parser Body -> Parser Body
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Located (RType BTyCon BTyVar RReft) -> Parser Body
tyBodyP Located (RType BTyCon BTyVar RReft)
ty)
  Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
-> StateT
     PState
     (Parsec Void [Char])
     (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return   (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
 -> StateT
      PState
      (Parsec Void [Char])
      (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol))
-> Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
-> StateT
     PState
     (Parsec Void [Char])
     (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol)
forall a b. (a -> b) -> a -> b
$ LocSymbol
-> Located (RType BTyCon BTyVar RReft)
-> [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
-> MeasureKind
-> UnSortedExprs
-> Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol
forall ty bndr.
LocSymbol
-> ty
-> [Def ty bndr]
-> MeasureKind
-> UnSortedExprs
-> Measure ty bndr
Measure.mkM LocSymbol
x Located (RType BTyCon BTyVar RReft)
ty [Def (Located (RType BTyCon BTyVar RReft)) LocSymbol]
eqns MeasureKind
MsMeasure UnSortedExprs
forall a. Monoid a => a
mempty

-- | class measure
cMeasureP :: Parser (Measure (Located BareType) ())
cMeasureP :: StateT
  PState
  (Parsec Void [Char])
  (Measure (Located (RType BTyCon BTyVar RReft)) ())
cMeasureP
  = do (LocSymbol
x, Located (RType BTyCon BTyVar RReft)
ty) <- StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
tyBindP
       Measure (Located (RType BTyCon BTyVar RReft)) ()
-> StateT
     PState
     (Parsec Void [Char])
     (Measure (Located (RType BTyCon BTyVar RReft)) ())
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Measure (Located (RType BTyCon BTyVar RReft)) ()
 -> StateT
      PState
      (Parsec Void [Char])
      (Measure (Located (RType BTyCon BTyVar RReft)) ()))
-> Measure (Located (RType BTyCon BTyVar RReft)) ()
-> StateT
     PState
     (Parsec Void [Char])
     (Measure (Located (RType BTyCon BTyVar RReft)) ())
forall a b. (a -> b) -> a -> b
$ LocSymbol
-> Located (RType BTyCon BTyVar RReft)
-> [Def (Located (RType BTyCon BTyVar RReft)) ()]
-> MeasureKind
-> UnSortedExprs
-> Measure (Located (RType BTyCon BTyVar RReft)) ()
forall ty bndr.
LocSymbol
-> ty
-> [Def ty bndr]
-> MeasureKind
-> UnSortedExprs
-> Measure ty bndr
Measure.mkM LocSymbol
x Located (RType BTyCon BTyVar RReft)
ty [] MeasureKind
MsClass UnSortedExprs
forall a. Monoid a => a
mempty

iMeasureP :: Parser (Measure (Located BareType) LocSymbol)
iMeasureP :: StateT
  PState
  (Parsec Void [Char])
  (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol)
iMeasureP = StateT
  PState
  (Parsec Void [Char])
  (Measure (Located (RType BTyCon BTyVar RReft)) LocSymbol)
measureP


oneClassArg :: Parser [Located BareType]
oneClassArg :: StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
oneClassArg
  = Located (RType BTyCon BTyVar RReft)
-> [Located (RType BTyCon BTyVar RReft)]
forall a. a -> [a]
sing (Located (RType BTyCon BTyVar RReft)
 -> [Located (RType BTyCon BTyVar RReft)])
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located (BTyCon -> [BTyVar] -> RType BTyCon BTyVar RReft
forall {r} {c} {tv}. Monoid r => c -> [tv] -> RType c tv r
rit (BTyCon -> [BTyVar] -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) BTyCon
-> StateT
     PState (Parsec Void [Char]) ([BTyVar] -> RType BTyCon BTyVar RReft)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) BTyCon
classBTyConP StateT
  PState (Parsec Void [Char]) ([BTyVar] -> RType BTyCon BTyVar RReft)
-> Parser [BTyVar]
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (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 PState (Parsec Void [Char]) [Located BTyVar]
-> Parser [BTyVar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) [Located BTyVar]
classParams))
  where
    rit :: c -> [tv] -> RType c tv r
rit c
t [tv]
as    = c -> [RType c tv r] -> [RTProp c tv r] -> r -> RType c tv r
forall c tv r.
c -> [RType c tv r] -> [RTProp c tv r] -> r -> RType c tv r
RApp c
t ((tv -> r -> RType c tv r
forall c tv r. tv -> r -> RType c tv r
`RVar` r
forall a. Monoid a => a
mempty) (tv -> RType c tv r) -> [tv] -> [RType c tv r]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [tv]
as) [] r
forall a. Monoid a => a
mempty
    classParams :: StateT PState (Parsec Void [Char]) [Located BTyVar]
classParams =  ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"where" StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) [Located BTyVar]
-> StateT PState (Parsec Void [Char]) [Located BTyVar]
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Located BTyVar]
-> StateT PState (Parsec Void [Char]) [Located BTyVar]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return [])
               StateT PState (Parsec Void [Char]) [Located BTyVar]
-> StateT PState (Parsec Void [Char]) [Located BTyVar]
-> StateT PState (Parsec Void [Char]) [Located BTyVar]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((:) (Located BTyVar -> [Located BTyVar] -> [Located BTyVar])
-> StateT PState (Parsec Void [Char]) (Located BTyVar)
-> StateT
     PState (Parsec Void [Char]) ([Located BTyVar] -> [Located BTyVar])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Symbol -> BTyVar) -> LocSymbol -> Located BTyVar
forall a b. (a -> b) -> Located a -> Located b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Symbol -> BTyVar
bTyVar (LocSymbol -> Located BTyVar)
-> StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) (Located BTyVar)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) LocSymbol
locLowerIdP) StateT
  PState (Parsec Void [Char]) ([Located BTyVar] -> [Located BTyVar])
-> StateT PState (Parsec Void [Char]) [Located BTyVar]
-> StateT PState (Parsec Void [Char]) [Located BTyVar]
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT PState (Parsec Void [Char]) [Located BTyVar]
classParams)
    sing :: a -> [a]
sing a
x      = [a
x]


superP :: Parser (Located BareType)
superP :: StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
superP = StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located (RType BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft
forall a. a -> a
toRCls (RType BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareAtomBindP)
  where toRCls :: p -> p
toRCls p
x = p
x

instanceLawP :: Parser (RILaws (Located BareType))
instanceLawP :: StateT
  PState
  (Parsec Void [Char])
  (RILaws (Located (RType BTyCon BTyVar RReft)))
instanceLawP
  = do SourcePos
l1   <- StateT PState (Parsec Void [Char]) SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
       [Located (RType BTyCon BTyVar RReft)]
sups <- StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
supersP
       BTyCon
c    <- StateT PState (Parsec Void [Char]) BTyCon
classBTyConP
       [Located (RType BTyCon BTyVar RReft)]
tvs  <- StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) ()
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
manyTill (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP) (StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) ()
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (StateT PState (Parsec Void [Char]) ()
 -> StateT PState (Parsec Void [Char]) ())
-> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) ()
forall a b. (a -> b) -> a -> b
$ [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"where")
       [(LocSymbol, LocSymbol)]
ms   <- Parser (LocSymbol, LocSymbol) -> Parser [(LocSymbol, LocSymbol)]
forall a. Parser a -> Parser [a]
block Parser (LocSymbol, LocSymbol)
eqBinderP
       SourcePos
l2   <- StateT PState (Parsec Void [Char]) SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
       RILaws (Located (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (RILaws (Located (RType BTyCon BTyVar RReft)))
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (RILaws (Located (RType BTyCon BTyVar RReft))
 -> StateT
      PState
      (Parsec Void [Char])
      (RILaws (Located (RType BTyCon BTyVar RReft))))
-> RILaws (Located (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     (RILaws (Located (RType BTyCon BTyVar RReft)))
forall a b. (a -> b) -> a -> b
$ BTyCon
-> [Located (RType BTyCon BTyVar RReft)]
-> [Located (RType BTyCon BTyVar RReft)]
-> [(LocSymbol, LocSymbol)]
-> Located ()
-> RILaws (Located (RType BTyCon BTyVar RReft))
forall ty.
BTyCon
-> [ty]
-> [ty]
-> [(LocSymbol, LocSymbol)]
-> Located ()
-> RILaws ty
RIL BTyCon
c [Located (RType BTyCon BTyVar RReft)]
sups [Located (RType BTyCon BTyVar RReft)]
tvs [(LocSymbol, LocSymbol)]
ms (SourcePos -> SourcePos -> () -> Located ()
forall a. SourcePos -> SourcePos -> a -> Located a
Loc SourcePos
l1 SourcePos
l2 ())
  where
    supersP :: StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
supersP  = StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ((StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall a. Parser a -> Parser a
parens (StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
superP StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) [Char]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
`sepBy1` StateT PState (Parsec Void [Char]) [Char]
comma) StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Located (RType BTyCon BTyVar RReft)
 -> [Located (RType BTyCon BTyVar RReft)])
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall a b.
(a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located (RType BTyCon BTyVar RReft)
-> [Located (RType BTyCon BTyVar RReft)]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
superP)
                       StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT PState (Parsec Void [Char]) ()
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"=>")
               StateT
  PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Located (RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [Located (RType BTyCon BTyVar RReft)]
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return []

    eqBinderP :: Parser (LocSymbol, LocSymbol)
eqBinderP = StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) LocSymbol
-> Parser (LocSymbol, LocSymbol)
forall x a y. Parser x -> Parser a -> Parser y -> Parser (x, y)
xyP StateT PState (Parsec Void [Char]) LocSymbol
xP ([Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"=") StateT PState (Parsec Void [Char]) LocSymbol
xP

    xP :: StateT PState (Parsec Void [Char]) LocSymbol
xP = StateT PState (Parsec Void [Char]) LocSymbol
locBinderP

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

    iargsP :: StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
iargsP   =   (BTyVar -> Located (RType BTyCon BTyVar RReft)
forall {r} {tv} {c}. Monoid r => tv -> Located (RType c tv r)
mkVar (BTyVar -> Located (RType BTyCon BTyVar RReft))
-> (Symbol -> BTyVar)
-> Symbol
-> Located (RType BTyCon BTyVar RReft)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Symbol -> BTyVar
bTyVar (Symbol -> Located (RType BTyCon BTyVar RReft))
-> Parser Symbol
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
tyVarIdP)
            StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> StateT
  PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser a
parens (StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP)


    mkVar :: tv -> Located (RType c tv r)
mkVar tv
v  = RType c tv r -> Located (RType c tv r)
forall a. a -> Located a
dummyLoc (RType c tv r -> Located (RType c tv r))
-> RType c tv r -> Located (RType c tv r)
forall a b. (a -> b) -> a -> b
$ tv -> r -> RType c tv r
forall c tv r. tv -> r -> RType c tv r
RVar tv
v r
forall a. Monoid a => a
mempty


riMethodSigP :: Parser (LocSymbol, RISig (Located BareType))
riMethodSigP :: Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
riMethodSigP
  = Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
-> Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (do [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"assume"
            (LocSymbol
x, Located (RType BTyCon BTyVar RReft)
t) <- StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
tyBindP
            (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
-> Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (LocSymbol
x, Located (RType BTyCon BTyVar RReft)
-> RISig (Located (RType BTyCon BTyVar RReft))
forall t. t -> RISig t
RIAssumed Located (RType BTyCon BTyVar RReft)
t) )
 Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
-> Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
-> Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> do (LocSymbol
x, Located (RType BTyCon BTyVar RReft)
t) <- StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, Located (RType BTyCon BTyVar RReft))
tyBindP
        (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
-> Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (LocSymbol
x, Located (RType BTyCon BTyVar RReft)
-> RISig (Located (RType BTyCon BTyVar RReft))
forall t. t -> RISig t
RISig Located (RType BTyCon BTyVar RReft)
t)
 Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
-> [Char]
-> Parser (LocSymbol, RISig (Located (RType BTyCon BTyVar RReft)))
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"riMethodSigP"

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

rawBodyP :: Parser Body
rawBodyP :: Parser Body
rawBodyP
  = Parser Body -> Parser Body
forall a. Parser a -> Parser a
braces (Parser Body -> Parser Body) -> Parser Body -> Parser Body
forall a b. (a -> b) -> a -> b
$ do
      Symbol
v <- Parser Symbol
symbolP
      [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"|"
      Symbol -> Expr -> Body
R Symbol
v (Expr -> Body) -> Parser Expr -> Parser Body
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
predP

tyBodyP :: Located BareType -> Parser Body
tyBodyP :: Located (RType BTyCon BTyVar RReft) -> Parser Body
tyBodyP Located (RType BTyCon BTyVar RReft)
ty
  = case RType BTyCon BTyVar RReft -> Maybe (RType BTyCon BTyVar RReft)
forall {c} {tv} {r}. RType c tv r -> Maybe (RType c tv r)
outTy (Located (RType BTyCon BTyVar RReft) -> RType BTyCon BTyVar RReft
forall a. Located a -> a
val Located (RType BTyCon BTyVar RReft)
ty) of
      Just RType BTyCon BTyVar RReft
bt | RType BTyCon BTyVar RReft -> Bool
forall t t1. RType BTyCon t t1 -> Bool
isPropBareType RType BTyCon BTyVar RReft
bt
                -> Expr -> Body
P (Expr -> Body) -> Parser Expr -> Parser Body
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
predP
      Maybe (RType BTyCon BTyVar RReft)
_         -> Expr -> Body
E (Expr -> Body) -> Parser Expr -> Parser Body
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
exprP
    where outTy :: RType c tv r -> Maybe (RType c tv r)
outTy (RAllT RTVU c tv
_ RType c tv r
t r
_)    = RType c tv r -> Maybe (RType c tv r)
outTy RType c tv r
t
          outTy (RAllP PVU c tv
_ RType c tv r
t)      = RType c tv r -> Maybe (RType c tv r)
outTy RType c tv r
t
          outTy (RFun Symbol
_ RFInfo
_ RType c tv r
_ RType c tv r
t r
_) = RType c tv r -> Maybe (RType c tv r)
forall a. a -> Maybe a
Just RType c tv r
t
          outTy RType c tv r
_                = Maybe (RType c tv r)
forall a. Maybe a
Nothing

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

locBinderP :: Parser (Located Symbol)
locBinderP :: StateT PState (Parsec Void [Char]) LocSymbol
locBinderP =
  Parser Symbol -> StateT PState (Parsec Void [Char]) LocSymbol
forall a. Parser a -> Parser (Located a)
located Parser Symbol
binderP -- TODO

-- | 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 =
      Text -> Symbol
forall a. Symbolic a => a -> Symbol
symbol (Text -> Symbol) -> (Symbol -> Text) -> Symbol -> Symbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ Text
x -> Text
"(" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
x Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
")") (Text -> Text) -> (Symbol -> Text) -> Symbol -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Symbol -> Text
symbolText (Symbol -> Symbol) -> Parser Symbol -> Parser Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol -> Parser Symbol
forall a. Parser a -> Parser a
parens Parser Symbol
infixBinderIdP
  Parser Symbol -> Parser Symbol -> Parser Symbol
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (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.
  --
  -- TODO, Andres: I have no idea why we make the parens part of the symbol here.
  -- But I'm reproducing this behaviour for now, as it is backed up via a few tests.

measureDefP :: Parser Body -> Parser (Def (Located BareType) LocSymbol)
measureDefP :: Parser Body
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
measureDefP Parser Body
bodyP
  = do LocSymbol
mname   <- StateT PState (Parsec Void [Char]) LocSymbol
locSymbolP
       (LocSymbol
c, [LocSymbol]
xs) <- StateT PState (Parsec Void [Char]) (LocSymbol, [LocSymbol])
measurePatP
       [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"="
       Body
body    <- Parser Body
bodyP
       let xs' :: [Symbol]
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
       Def (Located (RType BTyCon BTyVar RReft)) LocSymbol
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return   (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol
 -> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol))
-> Def (Located (RType BTyCon BTyVar RReft)) LocSymbol
-> Parser (Def (Located (RType BTyCon BTyVar RReft)) LocSymbol)
forall a b. (a -> b) -> a -> b
$ LocSymbol
-> LocSymbol
-> Maybe (Located (RType BTyCon BTyVar RReft))
-> [(Symbol, Maybe (Located (RType BTyCon BTyVar RReft)))]
-> Body
-> Def (Located (RType BTyCon BTyVar RReft)) LocSymbol
forall ty ctor.
LocSymbol
-> ctor -> Maybe ty -> [(Symbol, Maybe ty)] -> Body -> Def ty ctor
Def LocSymbol
mname (Symbol -> Symbol
forall a. Symbolic a => a -> Symbol
symbol (Symbol -> Symbol) -> LocSymbol -> LocSymbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LocSymbol
c) Maybe (Located (RType BTyCon BTyVar RReft))
forall a. Maybe a
Nothing ((, Maybe (Located (RType BTyCon BTyVar RReft))
forall a. Maybe a
Nothing) (Symbol -> (Symbol, Maybe (Located (RType BTyCon BTyVar RReft))))
-> [Symbol]
-> [(Symbol, Maybe (Located (RType BTyCon BTyVar RReft)))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Symbol]
xs') Body
body

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

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

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

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

nilPatP :: IsString a
        => Parser (Located a, [t])
nilPatP :: forall a t. IsString a => Parser (Located a, [t])
nilPatP  = () -> (Located a, [t])
forall a t t1. IsString a => t -> (Located a, [t1])
mkNilPat  (() -> (Located a, [t]))
-> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) (Located a, [t])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) ()
forall a. Parser a -> Parser a
brackets (() -> StateT PState (Parsec Void [Char]) ()
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())

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

mkTupPat :: Foldable t => t a -> (Located Symbol, t a)
mkTupPat :: forall (t :: * -> *) a. Foldable t => t a -> (LocSymbol, t a)
mkTupPat t a
zs     = (Int -> LocSymbol
tupDataCon (t a -> Int
forall a. t a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
zs), t a
zs)

mkNilPat :: IsString a => t -> (Located a, [t1])
mkNilPat :: forall a t t1. IsString a => t -> (Located a, [t1])
mkNilPat t
_      = (a -> Located a
forall a. a -> Located a
dummyLoc a
"[]", []    )

mkConsPat :: IsString a => t1 -> t -> t1 -> (Located a, [t1])
mkConsPat :: forall a t1 t. IsString a => t1 -> t -> t1 -> (Located a, [t1])
mkConsPat t1
x t
_ t1
y = (a -> Located a
forall a. a -> Located a
dummyLoc a
":" , [t1
x, t1
y])

tupDataCon :: Int -> Located Symbol
tupDataCon :: Int -> LocSymbol
tupDataCon Int
n    = Symbol -> LocSymbol
forall a. a -> Located a
dummyLoc (Symbol -> LocSymbol) -> Symbol -> LocSymbol
forall a b. (a -> b) -> a -> b
$ [Char] -> Symbol
forall a. Symbolic a => a -> Symbol
symbol ([Char] -> Symbol) -> [Char] -> Symbol
forall a b. (a -> b) -> a -> b
$ [Char]
"(" [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Char
',' [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
")"


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

dataConFieldsP :: Parser [(Symbol, BareType)]
dataConFieldsP :: StateT
  PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
dataConFieldsP
   =  Parser (Symbol, RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
forall a. Parser a -> Parser [a]
explicitCommaBlock Parser (Symbol, RType BTyCon BTyVar RReft)
predTypeDDP -- braces (sepBy predTypeDDP comma)
  StateT
  PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser (Symbol, RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many Parser (Symbol, RType BTyCon BTyVar RReft)
dataConFieldP
  StateT
  PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
-> [Char]
-> StateT
     PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"dataConFieldP"

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

predTypeDDP :: Parser (Symbol, BareType)
predTypeDDP :: Parser (Symbol, RType BTyCon BTyVar RReft)
predTypeDDP = (,) (Symbol
 -> RType BTyCon BTyVar RReft
 -> (Symbol, RType BTyCon BTyVar RReft))
-> Parser Symbol
-> StateT
     PState
     (Parsec Void [Char])
     (RType BTyCon BTyVar RReft -> (Symbol, RType BTyCon BTyVar RReft))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Symbol
bbindP StateT
  PState
  (Parsec Void [Char])
  (RType BTyCon BTyVar RReft -> (Symbol, RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> Parser (Symbol, RType BTyCon BTyVar RReft)
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP

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

dataConP :: [Symbol] -> Parser DataCtor
dataConP :: [Symbol] -> Parser DataCtor
dataConP [Symbol]
as = do
  LocSymbol
x   <- StateT PState (Parsec Void [Char]) LocSymbol
dataConNameP
  [(Symbol, RType BTyCon BTyVar RReft)]
xts <- StateT
  PState (Parsec Void [Char]) [(Symbol, RType BTyCon BTyVar RReft)]
dataConFieldsP
  DataCtor -> Parser DataCtor
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (DataCtor -> Parser DataCtor) -> DataCtor -> Parser DataCtor
forall a b. (a -> b) -> a -> b
$ LocSymbol
-> [Symbol]
-> [RType BTyCon BTyVar RReft]
-> [(Symbol, RType BTyCon BTyVar RReft)]
-> Maybe (RType BTyCon BTyVar RReft)
-> DataCtor
DataCtor LocSymbol
x [Symbol]
as [] [(Symbol, RType BTyCon BTyVar RReft)]
xts Maybe (RType BTyCon BTyVar RReft)
forall a. Maybe a
Nothing

adtDataConP :: [Symbol] -> Parser DataCtor
adtDataConP :: [Symbol] -> Parser DataCtor
adtDataConP [Symbol]
as = do
  LocSymbol
x     <- StateT PState (Parsec Void [Char]) LocSymbol
dataConNameP
  [Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"::"
  RTypeRep BTyCon BTyVar RReft
tr    <- RType BTyCon BTyVar RReft -> RTypeRep BTyCon BTyVar RReft
forall c tv r. RType c tv r -> RTypeRep c tv r
toRTypeRep (RType BTyCon BTyVar RReft -> RTypeRep BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (RTypeRep BTyCon BTyVar RReft)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP
  DataCtor -> Parser DataCtor
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (DataCtor -> Parser DataCtor) -> DataCtor -> Parser DataCtor
forall a b. (a -> b) -> a -> b
$ LocSymbol
-> [Symbol]
-> [RType BTyCon BTyVar RReft]
-> [(Symbol, RType BTyCon BTyVar RReft)]
-> Maybe (RType BTyCon BTyVar RReft)
-> DataCtor
DataCtor LocSymbol
x ([Symbol] -> RTypeRep BTyCon BTyVar RReft -> [Symbol]
forall a c r. Symbolic a => [Symbol] -> RTypeRep c a r -> [Symbol]
tRepVars [Symbol]
as RTypeRep BTyCon BTyVar RReft
tr) [] (RTypeRep BTyCon BTyVar RReft
-> [(Symbol, RType BTyCon BTyVar RReft)]
forall c tv r. RTypeRep c tv r -> [(Symbol, RType c tv r)]
tRepFields RTypeRep BTyCon BTyVar RReft
tr) (RType BTyCon BTyVar RReft -> Maybe (RType BTyCon BTyVar RReft)
forall a. a -> Maybe a
Just (RType BTyCon BTyVar RReft -> Maybe (RType BTyCon BTyVar RReft))
-> RType BTyCon BTyVar RReft -> Maybe (RType BTyCon BTyVar RReft)
forall a b. (a -> b) -> a -> b
$ RTypeRep BTyCon BTyVar RReft -> RType BTyCon BTyVar RReft
forall c tv r. RTypeRep c tv r -> RType c tv r
ty_res RTypeRep BTyCon BTyVar RReft
tr)

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

tRepFields :: RTypeRep c tv r -> [(Symbol, RType c tv r)]
tRepFields :: forall c tv r. RTypeRep c tv r -> [(Symbol, RType c tv r)]
tRepFields RTypeRep c tv r
tr = [Symbol] -> [RType c tv r] -> [(Symbol, RType c tv r)]
forall a b. [a] -> [b] -> [(a, b)]
zip (RTypeRep c tv r -> [Symbol]
forall c tv r. RTypeRep c tv r -> [Symbol]
ty_binds RTypeRep c tv r
tr) (RTypeRep c tv r -> [RType c tv r]
forall c tv r. RTypeRep c tv r -> [RType c tv r]
ty_args RTypeRep c tv r
tr)

-- TODO: fix Located
dataConNameP :: Parser (Located Symbol)
dataConNameP :: StateT PState (Parsec Void [Char]) LocSymbol
dataConNameP
  =  Parser Symbol -> StateT PState (Parsec Void [Char]) LocSymbol
forall a. Parser a -> Parser (Located a)
located
 (   Parser Symbol -> Parser Symbol
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser Symbol
upperIdP
 Parser Symbol -> Parser Symbol -> Parser Symbol
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Tokens [Char] -> Symbol
forall {a}. (Symbolic a, Semigroup a, IsString a) => a -> Symbol
pwr (Tokens [Char] -> Symbol)
-> StateT PState (Parsec Void [Char]) (Tokens [Char])
-> Parser Symbol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) (Tokens [Char])
-> StateT PState (Parsec Void [Char]) (Tokens [Char])
forall a. Parser a -> Parser a
parens ((Token [Char] -> Bool)
-> StateT PState (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 -> Symbol) -> a -> Symbol
forall a b. (a -> b) -> a -> b
$ a
"(" a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
s a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
")"

dataSizeP :: Parser (Maybe SizeFun)
dataSizeP :: Parser (Maybe SizeFun)
dataSizeP
  = Parser (Maybe SizeFun) -> Parser (Maybe SizeFun)
forall a. Parser a -> Parser a
brackets (SizeFun -> Maybe SizeFun
forall a. a -> Maybe a
Just (SizeFun -> Maybe SizeFun)
-> (LocSymbol -> SizeFun) -> LocSymbol -> Maybe SizeFun
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocSymbol -> SizeFun
SymSizeFun (LocSymbol -> Maybe SizeFun)
-> StateT PState (Parsec Void [Char]) LocSymbol
-> Parser (Maybe SizeFun)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) LocSymbol
locLowerIdP)
  Parser (Maybe SizeFun)
-> Parser (Maybe SizeFun) -> Parser (Maybe SizeFun)
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe SizeFun -> Parser (Maybe SizeFun)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SizeFun
forall a. Maybe a
Nothing

relationalP :: Parser (LocSymbol, LocSymbol, LocBareType, LocBareType, RelExpr, RelExpr)
relationalP :: StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
   Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
relationalP = do
   LocSymbol
x <- StateT PState (Parsec Void [Char]) LocSymbol
locBinderP
   [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"~"
   LocSymbol
y <- StateT PState (Parsec Void [Char]) LocSymbol
locBinderP
   [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"::"
   StateT
  PState
  (Parsec Void [Char])
  (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
   Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
      Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
forall a. Parser a -> Parser a
braces (StateT
   PState
   (Parsec Void [Char])
   (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
    Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
 -> StateT
      PState
      (Parsec Void [Char])
      (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
       Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr))
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
      Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
      Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
forall a b. (a -> b) -> a -> b
$ do
    Located (RType BTyCon BTyVar RReft)
tx <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
genBareTypeP
    [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"~"
    Located (RType BTyCon BTyVar RReft)
ty <- StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Located (RType BTyCon BTyVar RReft))
forall a. Parser a -> Parser (Located a)
located StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
genBareTypeP
    [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"|"
    RelExpr
assm <- Parser RelExpr -> Parser RelExpr
forall a. Parser a -> Parser a
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Parser RelExpr
relrefaP Parser RelExpr
-> StateT PState (Parsec Void [Char]) () -> Parser RelExpr
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* [Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"|-") Parser RelExpr -> Parser RelExpr -> Parser RelExpr
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelExpr -> Parser RelExpr
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Expr -> RelExpr
ERBasic Expr
PTrue)
    RelExpr
ex <- Parser RelExpr
relrefaP
    (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
 Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
-> StateT
     PState
     (Parsec Void [Char])
     (LocSymbol, LocSymbol, Located (RType BTyCon BTyVar RReft),
      Located (RType BTyCon BTyVar RReft), RelExpr, RelExpr)
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (LocSymbol
x,LocSymbol
y,Located (RType BTyCon BTyVar RReft)
tx,Located (RType BTyCon BTyVar RReft)
ty,RelExpr
assm,RelExpr
ex)

dataDeclP :: Parser DataDecl
dataDeclP :: StateT PState (Parsec Void [Char]) DataDecl
dataDeclP = do
  SourcePos
pos <- StateT PState (Parsec Void [Char]) SourcePos
forall s e (m :: * -> *).
(TraversableStream s, MonadParsec e s m) =>
m SourcePos
getSourcePos
  LocSymbol
x   <- StateT PState (Parsec Void [Char]) LocSymbol
locUpperOrInfixIdP
  Maybe SizeFun
fsize <- Parser (Maybe SizeFun)
dataSizeP
  SourcePos
-> LocSymbol
-> Maybe SizeFun
-> StateT PState (Parsec Void [Char]) DataDecl
dataDeclBodyP SourcePos
pos LocSymbol
x Maybe SizeFun
fsize StateT PState (Parsec Void [Char]) DataDecl
-> StateT PState (Parsec Void [Char]) DataDecl
-> StateT PState (Parsec Void [Char]) DataDecl
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> DataDecl -> StateT PState (Parsec Void [Char]) DataDecl
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (LocSymbol -> SourcePos -> Maybe SizeFun -> DataDecl
emptyDecl LocSymbol
x SourcePos
pos Maybe SizeFun
fsize)

emptyDecl :: LocSymbol -> SourcePos -> Maybe SizeFun -> DataDecl
emptyDecl :: LocSymbol -> SourcePos -> Maybe SizeFun -> DataDecl
emptyDecl LocSymbol
x SourcePos
pos fsize :: Maybe SizeFun
fsize@(Just SizeFun
_)
  = DataName
-> [Symbol]
-> [PVar (RType BTyCon BTyVar ())]
-> Maybe [DataCtor]
-> SourcePos
-> Maybe SizeFun
-> Maybe (RType BTyCon BTyVar RReft)
-> DataDeclKind
-> DataDecl
DataDecl (LocSymbol -> DataName
DnName LocSymbol
x) [] [] Maybe [DataCtor]
forall a. Maybe a
Nothing SourcePos
pos Maybe SizeFun
fsize Maybe (RType BTyCon BTyVar RReft)
forall a. Maybe a
Nothing DataDeclKind
DataUser
emptyDecl LocSymbol
x SourcePos
pos Maybe SizeFun
_
  = UserError -> DataDecl
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 SizeFun -> Parser DataDecl
dataDeclBodyP :: SourcePos
-> LocSymbol
-> Maybe SizeFun
-> StateT PState (Parsec Void [Char]) DataDecl
dataDeclBodyP SourcePos
pos LocSymbol
x Maybe SizeFun
fsize = do
  Bool
vanilla    <- [LocSymbol] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([LocSymbol] -> Bool)
-> StateT PState (Parsec Void [Char]) [LocSymbol]
-> StateT PState (Parsec Void [Char]) Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) LocSymbol
-> StateT PState (Parsec Void [Char]) [LocSymbol]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many StateT PState (Parsec Void [Char]) LocSymbol
locUpperIdP
  [Symbol]
as         <- Parser Symbol -> StateT PState (Parsec Void [Char]) [Symbol]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many Parser Symbol
noWhere -- TODO: check this again
  [PVar (RType BTyCon BTyVar ())]
ps         <- Parser [PVar (RType BTyCon BTyVar ())]
predVarDefsP
  (Maybe (RType BTyCon BTyVar RReft)
pTy, [DataCtor]
dcs) <- [Symbol] -> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
dataCtorsP [Symbol]
as
  let dn :: DataName
dn      = SourcePos -> LocSymbol -> Bool -> [DataCtor] -> DataName
dataDeclName SourcePos
pos LocSymbol
x Bool
vanilla [DataCtor]
dcs
  DataDecl -> StateT PState (Parsec Void [Char]) DataDecl
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return      (DataDecl -> StateT PState (Parsec Void [Char]) DataDecl)
-> DataDecl -> StateT PState (Parsec Void [Char]) DataDecl
forall a b. (a -> b) -> a -> b
$ DataName
-> [Symbol]
-> [PVar (RType BTyCon BTyVar ())]
-> Maybe [DataCtor]
-> SourcePos
-> Maybe SizeFun
-> Maybe (RType BTyCon BTyVar RReft)
-> DataDeclKind
-> DataDecl
DataDecl DataName
dn [Symbol]
as [PVar (RType BTyCon BTyVar ())]
ps ([DataCtor] -> Maybe [DataCtor]
forall a. a -> Maybe a
Just [DataCtor]
dcs) SourcePos
pos Maybe SizeFun
fsize Maybe (RType BTyCon BTyVar RReft)
pTy DataDeclKind
DataUser

dataDeclName :: SourcePos -> LocSymbol -> Bool -> [DataCtor] -> DataName
dataDeclName :: SourcePos -> LocSymbol -> Bool -> [DataCtor] -> DataName
dataDeclName SourcePos
_ LocSymbol
x Bool
True  [DataCtor]
_     = LocSymbol -> DataName
DnName LocSymbol
x               -- vanilla data    declaration
dataDeclName SourcePos
_ LocSymbol
_ Bool
False (DataCtor
d:[DataCtor]
_) = LocSymbol -> DataName
DnCon  (DataCtor -> LocSymbol
dcName DataCtor
d)      -- family instance declaration
dataDeclName SourcePos
p LocSymbol
x Bool
_  [DataCtor]
_        = 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 BareType, [DataCtor])
dataCtorsP :: [Symbol] -> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
dataCtorsP [Symbol]
as = do
  (Maybe (RType BTyCon BTyVar RReft)
pTy, [DataCtor]
dcs) <-     ([Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"="     StateT PState (Parsec Void [Char]) ()
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Maybe (RType BTyCon BTyVar RReft)
forall a. Maybe a
Nothing, ) ([DataCtor] -> (Maybe (RType BTyCon BTyVar RReft), [DataCtor]))
-> StateT PState (Parsec Void [Char]) [DataCtor]
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>                 Parser DataCtor
-> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) [DataCtor]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy ([Symbol] -> Parser DataCtor
dataConP    [Symbol]
as) ([Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"|")))
                Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved   [Char]
"where" StateT PState (Parsec Void [Char]) ()
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ((Maybe (RType BTyCon BTyVar RReft)
forall a. Maybe a
Nothing, ) ([DataCtor] -> (Maybe (RType BTyCon BTyVar RReft), [DataCtor]))
-> StateT PState (Parsec Void [Char]) [DataCtor]
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>                 Parser DataCtor -> StateT PState (Parsec Void [Char]) [DataCtor]
forall a. Parser a -> Parser [a]
block ([Symbol] -> Parser DataCtor
adtDataConP [Symbol]
as)                 ))
                Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>                        ((,)         (Maybe (RType BTyCon BTyVar RReft)
 -> [DataCtor] -> (Maybe (RType BTyCon BTyVar RReft), [DataCtor]))
-> StateT
     PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
-> StateT
     PState
     (Parsec Void [Char])
     ([DataCtor] -> (Maybe (RType BTyCon BTyVar RReft), [DataCtor]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT
  PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
dataPropTyP StateT
  PState
  (Parsec Void [Char])
  ([DataCtor] -> (Maybe (RType BTyCon BTyVar RReft), [DataCtor]))
-> StateT PState (Parsec Void [Char]) [DataCtor]
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
forall a b.
StateT PState (Parsec Void [Char]) (a -> b)
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser DataCtor -> StateT PState (Parsec Void [Char]) [DataCtor]
forall a. Parser a -> Parser [a]
block ([Symbol] -> Parser DataCtor
adtDataConP [Symbol]
as)                  )
  (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
-> Parser (Maybe (RType BTyCon BTyVar RReft), [DataCtor])
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (RType BTyCon BTyVar RReft)
pTy, (DataCtor -> Symbol) -> [DataCtor] -> [DataCtor]
forall b a. Ord b => (a -> b) -> [a] -> [a]
Misc.sortOn (LocSymbol -> Symbol
forall a. Located a -> a
val (LocSymbol -> Symbol)
-> (DataCtor -> LocSymbol) -> DataCtor -> Symbol
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataCtor -> LocSymbol
dcName) [DataCtor]
dcs)

noWhere :: Parser Symbol
noWhere :: Parser Symbol
noWhere =
  Parser Symbol -> Parser Symbol
forall a. Parser a -> Parser 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
  Symbol
s <- Parser Symbol
tyVarIdP
  Bool -> StateT PState (Parsec Void [Char]) ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Symbol
s Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
/= Symbol
"where")
  Symbol -> Parser Symbol
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Symbol
s

dataPropTyP :: Parser (Maybe BareType)
dataPropTyP :: StateT
  PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
dataPropTyP = RType BTyCon BTyVar RReft -> Maybe (RType BTyCon BTyVar RReft)
forall a. a -> Maybe a
Just (RType BTyCon BTyVar RReft -> Maybe (RType BTyCon BTyVar RReft))
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT
     PState (Parsec Void [Char]) (Maybe (RType BTyCon BTyVar RReft))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) ()
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
-> StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between ([Char] -> StateT PState (Parsec Void [Char]) ()
reservedOp [Char]
"::") ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"where") StateT PState (Parsec Void [Char]) (RType BTyCon BTyVar RReft)
bareTypeP

---------------------------------------------------------------------
-- | Parsing Qualifiers ---------------------------------------------
---------------------------------------------------------------------

fTyConP :: Parser FTycon
fTyConP :: Parser FTycon
fTyConP
  =   ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"int"     StateT PState (Parsec Void [Char]) ()
-> Parser FTycon -> Parser FTycon
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> FTycon -> Parser FTycon
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return FTycon
intFTyCon)
  Parser FTycon -> Parser FTycon -> Parser FTycon
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"Integer" StateT PState (Parsec Void [Char]) ()
-> Parser FTycon -> Parser FTycon
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> FTycon -> Parser FTycon
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return FTycon
intFTyCon)
  Parser FTycon -> Parser FTycon -> Parser FTycon
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"Int"     StateT PState (Parsec Void [Char]) ()
-> Parser FTycon -> Parser FTycon
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> FTycon -> Parser FTycon
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return FTycon
intFTyCon)
  Parser FTycon -> Parser FTycon -> Parser FTycon
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"real"    StateT PState (Parsec Void [Char]) ()
-> Parser FTycon -> Parser FTycon
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> FTycon -> Parser FTycon
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return FTycon
realFTyCon)
  Parser FTycon -> Parser FTycon -> Parser FTycon
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ([Char] -> StateT PState (Parsec Void [Char]) ()
reserved [Char]
"bool"    StateT PState (Parsec Void [Char]) ()
-> Parser FTycon -> Parser FTycon
forall a b.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) b
-> StateT PState (Parsec Void [Char]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> FTycon -> Parser FTycon
forall a. a -> StateT PState (Parsec Void [Char]) a
forall (m :: * -> *) a. Monad m => a -> m a
return FTycon
boolFTyCon)
  Parser FTycon -> Parser FTycon -> Parser FTycon
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (LocSymbol -> FTycon
symbolFTycon      (LocSymbol -> FTycon)
-> StateT PState (Parsec Void [Char]) LocSymbol -> Parser FTycon
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT PState (Parsec Void [Char]) LocSymbol
locUpperIdP)
  Parser FTycon -> [Char] -> Parser FTycon
forall e s (m :: * -> *) a.
MonadParsec e s m =>
m a -> [Char] -> m a
<?> [Char]
"fTyConP"

---------------------------------------------------------------------
-- 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 PState (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
condIdR (StateT PState (Parsec Void [Char]) Char
StateT PState (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
lowerChar StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Token [Char] -> StateT PState (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 a. Parser a -> Parser a
lexeme Parser Symbol
tyVarIdR

aliasIdR :: Parser Symbol
aliasIdR :: Parser Symbol
aliasIdR =
  StateT PState (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
condIdR (StateT PState (Parsec Void [Char]) Char
StateT PState (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
letterChar StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Token [Char] -> StateT PState (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 a. Parser a -> Parser 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 PState (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
condIdR (StateT PState (Parsec Void [Char]) Char
StateT PState (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
letterChar StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Token [Char] -> StateT PState (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 PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Token [Char] -> Bool)
-> StateT PState (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 a. Parser a -> Parser a
lexeme Parser Symbol
binderIdR

infixBinderIdR :: Parser Symbol
infixBinderIdR :: Parser Symbol
infixBinderIdR =
  StateT PState (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
condIdR (StateT PState (Parsec Void [Char]) Char
StateT PState (Parsec Void [Char]) (Token [Char])
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
letterChar StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Token [Char] -> StateT PState (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 PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
-> StateT PState (Parsec Void [Char]) Char
forall a.
StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
-> StateT PState (Parsec Void [Char]) a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Token [Char] -> Bool)
-> StateT PState (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 a. Parser a -> Parser a
lexeme Parser Symbol
infixBinderIdR

upperIdR' :: Parser Symbol
upperIdR' :: Parser Symbol
upperIdR' =
  StateT PState (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
condIdR StateT PState (Parsec Void [Char]) Char
StateT PState (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' :: StateT PState (Parsec Void [Char]) LocSymbol
locUpperIdP' =
  Parser Symbol -> StateT PState (Parsec Void [Char]) LocSymbol
forall a. Parser a -> Parser (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 PState (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
condIdR (Token [Char] -> StateT PState (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 PState (Parsec Void [Char]) Char
-> (Char -> Bool) -> ([Char] -> Bool) -> [Char] -> Parser Symbol
condIdR ((Token [Char] -> Bool)
-> StateT PState (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 a. Parser a -> Parser 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 :: StateT PState (Parsec Void [Char]) LocSymbol
locInfixCondIdP =
  Parser Symbol -> StateT PState (Parsec Void [Char]) LocSymbol
forall a. Parser a -> Parser (Located a)
locLexeme Parser Symbol
infixCondIdR