-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Cryptol: The Language of Cryptography
--
-- Cryptol is a domain-specific language for specifying cryptographic
-- algorithms. A Cryptol implementation of an algorithm resembles its
-- mathematical specification more closely than an implementation in a
-- general purpose language. For more, see
-- http://www.cryptol.net/.
@package cryptol
@version 2.13.0
-- | A TBox-based implementation of AES primitives, based on the AES
-- example code from SBV. Here we've stripped out everything except the
-- basic primitives needed, which essentially boil down to table table
-- lookups in most cases.
module Cryptol.AES
-- | AES state. The state consists of four 32-bit words, each of which is
-- in turn treated as four GF28's, i.e., 4 bytes. The T-Box
-- implementation keeps the four-bytes together for efficient
-- representation.
type State = [Word32]
-- | The key, which can be 128, 192, or 256 bits. Represented as a sequence
-- of 32-bit words.
type Key = [Word32]
keyExpansionWords :: Integer -> Key -> [Word32]
-- | The InvMixColumns transformation, as described in Section
-- 5.3.3 of the standard. Note that this transformation is only used
-- explicitly during key-expansion in the T-Box implementation of AES.
invMixColumns :: State -> State
aesRound :: State -> State
aesFinalRound :: State -> State
aesInvRound :: State -> State
aesInvFinalRound :: State -> State
-- | Architecture-specific parts of the concrete evaluator go here.
module Cryptol.Backend.Arch
-- | This is the widest word we can have before gmp will fail to allocate
-- and bring down the whole program. According to
-- https://gmplib.org/list-archives/gmp-bugs/2009-July/001538.html
-- the sizes are 2^32-1 for 32-bit, and 2^37 for 64-bit, however
-- experiments show that it's somewhere under 2^37 at least on 64-bit Mac
-- OS X.
maxBigIntWidth :: Integer
module Cryptol.ModuleSystem.Fingerprint
data Fingerprint
-- | Compute a fingerprint for a bytestring.
fingerprint :: ByteString -> Fingerprint
-- | Attempt to compute the fingerprint of the file at the given path.
-- Returns Nothing in the case of an error.
fingerprintFile :: FilePath -> IO (Maybe Fingerprint)
instance GHC.Show.Show Cryptol.ModuleSystem.Fingerprint.Fingerprint
instance GHC.Classes.Eq Cryptol.ModuleSystem.Fingerprint.Fingerprint
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Fingerprint.Fingerprint
-- | Pure implementations of the SHA suite of hash functions. The
-- implementation is basically an unoptimized translation of FIPS 180-2
-- into Haskell. If you're looking for performance, you probably won't
-- find it here.
module Cryptol.SHA
data SHA256State
SHA256S :: !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> SHA256State
data SHA512State
SHA512S :: !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> SHA512State
data SHA256Block
SHA256Block :: !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> SHA256Block
data SHA512Block
SHA512Block :: !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> !Word64 -> SHA512Block
processSHA512Block :: SHA512State -> SHA512Block -> SHA512State
processSHA256Block :: SHA256State -> SHA256Block -> SHA256State
initialSHA224State :: SHA256State
initialSHA256State :: SHA256State
initialSHA384State :: SHA512State
initialSHA512State :: SHA512State
toBigEndianSBS :: (Integral a, Bits a) => Int -> a -> ByteString
fromBigEndianSBS :: (Integral a, Bits a) => ByteString -> a
calc_k :: Word64 -> Word64 -> Word64 -> Word64
padSHA1 :: ByteString -> ByteString
padSHA512 :: ByteString -> ByteString
padSHA1Chunks :: Int -> [ByteString]
padSHA512Chunks :: Int -> [ByteString]
module Cryptol.Utils.Fixity
-- | Information about associativity.
data Assoc
LeftAssoc :: Assoc
RightAssoc :: Assoc
NonAssoc :: Assoc
data Fixity
Fixity :: !Assoc -> !Int -> Fixity
[fAssoc] :: Fixity -> !Assoc
[fLevel] :: Fixity -> !Int
-- | The fixity used when none is provided.
defaultFixity :: Fixity
data FixityCmp
FCError :: FixityCmp
FCLeft :: FixityCmp
FCRight :: FixityCmp
-- | Let op1 have fixity f1 and op2 have fixity
-- f2. Then compareFixity f1 f2 determines how to parse the
-- infix expression x op1 y op2 z@.
--
--
-- - FCLeft: (x op1 y) op2 z
-- - FCRight: x op1 (y op2 z)
-- - FCError: no parse
--
compareFixity :: Fixity -> Fixity -> FixityCmp
instance Control.DeepSeq.NFData Cryptol.Utils.Fixity.Assoc
instance GHC.Generics.Generic Cryptol.Utils.Fixity.Assoc
instance GHC.Classes.Eq Cryptol.Utils.Fixity.Assoc
instance GHC.Show.Show Cryptol.Utils.Fixity.Assoc
instance GHC.Show.Show Cryptol.Utils.Fixity.Fixity
instance Control.DeepSeq.NFData Cryptol.Utils.Fixity.Fixity
instance GHC.Generics.Generic Cryptol.Utils.Fixity.Fixity
instance GHC.Classes.Eq Cryptol.Utils.Fixity.Fixity
instance GHC.Classes.Eq Cryptol.Utils.Fixity.FixityCmp
instance GHC.Show.Show Cryptol.Utils.Fixity.FixityCmp
module Cryptol.Utils.Ident
-- | Idnetifies a possibly nested module
data ModPath
TopModule :: ModName -> ModPath
Nested :: ModPath -> Ident -> ModPath
apPathRoot :: (ModName -> ModName) -> ModPath -> ModPath
-- | Compute a common prefix between two module paths, if any. This is
-- basically "anti-unification" of the two paths, where we compute the
-- longest common prefix, and the remaining differences for each module.
modPathCommon :: ModPath -> ModPath -> Maybe (ModPath, [Ident], [Ident])
topModuleFor :: ModPath -> ModName
modPathSplit :: ModPath -> (ModName, [Ident])
-- | Top-level Module names are just text.
data ModName
modNameToText :: ModName -> Text
textToModName :: Text -> ModName
modNameChunks :: ModName -> [String]
packModName :: [Text] -> ModName
preludeName :: ModName
preludeReferenceName :: ModName
floatName :: ModName
suiteBName :: ModName
arrayName :: ModName
primeECName :: ModName
interactiveName :: ModName
noModuleName :: ModName
exprModName :: ModName
isParamInstModName :: ModName -> Bool
-- | Convert a parameterized module's name to the name of the module
-- containing the same definitions but with explicit parameters on each
-- definition.
paramInstModName :: ModName -> ModName
notParamInstModName :: ModName -> ModName
-- | Identifiers, along with a flag that indicates whether or not they're
-- infix operators. The boolean is present just as cached information
-- from the lexer, and never used during comparisons.
data Ident
packIdent :: String -> Ident
packInfix :: String -> Ident
unpackIdent :: Ident -> String
mkIdent :: Text -> Ident
mkInfix :: Text -> Ident
isInfixIdent :: Ident -> Bool
nullIdent :: Ident -> Bool
identText :: Ident -> Text
modParamIdent :: Ident -> Ident
-- | Namespaces for names
data Namespace
NSValue :: Namespace
NSType :: Namespace
NSModule :: Namespace
allNamespaces :: [Namespace]
-- | Identifies an entitiy
data OrigName
OrigName :: Namespace -> ModPath -> Ident -> OrigName
[ogNamespace] :: OrigName -> Namespace
[ogModule] :: OrigName -> ModPath
[ogName] :: OrigName -> Ident
-- | A way to identify primitives: we used to use just Ident, but
-- this isn't good anymore as now we have primitives in multiple modules.
-- This is used as a key when we need to lookup details about a specific
-- primitive. Also, this is intended to mostly be used internally, so we
-- don't store the fixity flag of the Ident
data PrimIdent
PrimIdent :: ModName -> Text -> PrimIdent
-- | A shortcut to make (non-infix) primitives in the prelude.
prelPrim :: Text -> PrimIdent
floatPrim :: Text -> PrimIdent
arrayPrim :: Text -> PrimIdent
suiteBPrim :: Text -> PrimIdent
primeECPrim :: Text -> PrimIdent
instance GHC.Enum.Bounded Cryptol.Utils.Ident.Namespace
instance GHC.Enum.Enum Cryptol.Utils.Ident.Namespace
instance GHC.Classes.Ord Cryptol.Utils.Ident.Namespace
instance GHC.Classes.Eq Cryptol.Utils.Ident.Namespace
instance Control.DeepSeq.NFData Cryptol.Utils.Ident.Namespace
instance GHC.Show.Show Cryptol.Utils.Ident.Namespace
instance GHC.Generics.Generic Cryptol.Utils.Ident.Namespace
instance GHC.Generics.Generic Cryptol.Utils.Ident.ModName
instance GHC.Show.Show Cryptol.Utils.Ident.ModName
instance GHC.Classes.Ord Cryptol.Utils.Ident.ModName
instance GHC.Classes.Eq Cryptol.Utils.Ident.ModName
instance GHC.Generics.Generic Cryptol.Utils.Ident.Ident
instance GHC.Show.Show Cryptol.Utils.Ident.Ident
instance Control.DeepSeq.NFData Cryptol.Utils.Ident.ModPath
instance GHC.Generics.Generic Cryptol.Utils.Ident.ModPath
instance GHC.Show.Show Cryptol.Utils.Ident.ModPath
instance GHC.Classes.Ord Cryptol.Utils.Ident.ModPath
instance GHC.Classes.Eq Cryptol.Utils.Ident.ModPath
instance Control.DeepSeq.NFData Cryptol.Utils.Ident.OrigName
instance GHC.Generics.Generic Cryptol.Utils.Ident.OrigName
instance GHC.Show.Show Cryptol.Utils.Ident.OrigName
instance GHC.Classes.Ord Cryptol.Utils.Ident.OrigName
instance GHC.Classes.Eq Cryptol.Utils.Ident.OrigName
instance GHC.Generics.Generic Cryptol.Utils.Ident.PrimIdent
instance GHC.Show.Show Cryptol.Utils.Ident.PrimIdent
instance GHC.Classes.Ord Cryptol.Utils.Ident.PrimIdent
instance GHC.Classes.Eq Cryptol.Utils.Ident.PrimIdent
instance Control.DeepSeq.NFData Cryptol.Utils.Ident.PrimIdent
instance GHC.Classes.Eq Cryptol.Utils.Ident.Ident
instance GHC.Classes.Ord Cryptol.Utils.Ident.Ident
instance Data.String.IsString Cryptol.Utils.Ident.Ident
instance Control.DeepSeq.NFData Cryptol.Utils.Ident.Ident
instance Control.DeepSeq.NFData Cryptol.Utils.Ident.ModName
-- | A simple system so that the Cryptol driver can communicate with users
-- (or not).
module Cryptol.Utils.Logger
-- | A logger provides simple abstraction for sending messages.
data Logger
-- | Log to stdout.
stdoutLogger :: Logger
-- | Log to stderr.
stderrLogger :: Logger
-- | Log to the given handle.
handleLogger :: Handle -> Logger
-- | A logger that ignores all messages.
quietLogger :: Logger
-- | Just use this function for logging.
funLogger :: (String -> IO ()) -> Logger
-- | Send the given string to the log.
logPutStr :: Logger -> String -> IO ()
-- | Send the given string with a newline at the end.
logPutStrLn :: Logger -> String -> IO ()
-- | Send the given value using its Show instance. Adds a newline at
-- the end.
logPrint :: Show a => Logger -> a -> IO ()
instance Control.DeepSeq.NFData Cryptol.Utils.Logger.Logger
module Cryptol.Utils.Misc
-- | Apply a function to all elements of a container. Returns
-- Nothing if nothing changed, and Just container
-- otherwise.
anyJust :: Traversable t => (a -> Maybe a) -> t a -> Maybe (t a)
-- | Apply functions to both elements of a pair. Returns Nothing if
-- neither changed, and Just pair otherwise.
anyJust2 :: (a -> Maybe a) -> (b -> Maybe b) -> (a, b) -> Maybe (a, b)
module Cryptol.Utils.PP
-- | How to pretty print things when evaluating
data PPOpts
PPOpts :: Bool -> Int -> Int -> Int -> PPFloatFormat -> FieldOrder -> PPOpts
[useAscii] :: PPOpts -> Bool
[useBase] :: PPOpts -> Int
[useInfLength] :: PPOpts -> Int
[useFPBase] :: PPOpts -> Int
[useFPFormat] :: PPOpts -> PPFloatFormat
[useFieldOrder] :: PPOpts -> FieldOrder
asciiMode :: PPOpts -> Integer -> Bool
data PPFloatFormat
-- | Use this many significant digis
FloatFixed :: Int -> PPFloatExp -> PPFloatFormat
-- | Show this many digits after floating point
FloatFrac :: Int -> PPFloatFormat
-- | Use the correct number of digits
FloatFree :: PPFloatExp -> PPFloatFormat
data PPFloatExp
-- | Always show an exponent
ForceExponent :: PPFloatExp
-- | Only show exponent when needed
AutoExponent :: PPFloatExp
data FieldOrder
DisplayOrder :: FieldOrder
CanonicalOrder :: FieldOrder
defaultPPOpts :: PPOpts
-- | How to display names, inspired by the GHC Outputable module.
-- Getting a value of Nothing from the NameDisp function indicates
-- that the display has no opinion on how this name should be displayed,
-- and some other display should be tried out.
data NameDisp
EmptyNameDisp :: NameDisp
NameDisp :: (OrigName -> Maybe NameFormat) -> NameDisp
data NameFormat
UnQualified :: NameFormat
Qualified :: !ModName -> NameFormat
NotInScope :: NameFormat
-- | Never qualify names from this module.
neverQualifyMod :: ModPath -> NameDisp
neverQualify :: NameDisp
-- | Compose two naming environments, preferring names from the left
-- environment.
extend :: NameDisp -> NameDisp -> NameDisp
-- | Get the format for a name. When Nothing is returned, the name
-- is not currently in scope.
getNameFormat :: OrigName -> NameDisp -> NameFormat
-- | Produce a document in the context of the current NameDisp.
withNameDisp :: (NameDisp -> Doc) -> Doc
-- | Fix the way that names are displayed inside of a doc.
fixNameDisp :: NameDisp -> Doc -> Doc
newtype Doc
Doc :: (NameDisp -> Doc Void) -> Doc
runDoc :: NameDisp -> Doc -> Doc Void
renderOneLine :: Doc -> String
class PP a
ppPrec :: PP a => Int -> a -> Doc
class PP a => PPName a
-- | Fixity information for infix operators
ppNameFixity :: PPName a => a -> Maybe Fixity
-- | Print a name in prefix: f a b or (+) a b)
ppPrefixName :: PPName a => a -> Doc
-- | Print a name as an infix operator: a + b
ppInfixName :: PPName a => a -> Doc
pp :: PP a => a -> Doc
pretty :: PP a => a -> String
optParens :: Bool -> Doc -> Doc
-- | Information about an infix expression of some sort.
data Infix op thing
Infix :: op -> thing -> thing -> Fixity -> Infix op thing
-- | operator
[ieOp] :: Infix op thing -> op
-- | left argument
[ieLeft] :: Infix op thing -> thing
-- | right argument
[ieRight] :: Infix op thing -> thing
-- | operator fixity
[ieFixity] :: Infix op thing -> Fixity
-- | Pretty print an infix expression of some sort.
ppInfix :: (PP thing, PP op) => Int -> (thing -> Maybe (Infix op thing)) -> Infix op thing -> Doc
-- | Display a numeric value as an ordinal (e.g., 2nd)
ordinal :: (Integral a, Show a, Eq a) => a -> Doc
-- | The suffix to use when displaying a number as an oridinal
ordSuffix :: (Integral a, Eq a) => a -> String
liftPP :: Doc Void -> Doc
liftPP1 :: (Doc Void -> Doc Void) -> Doc -> Doc
liftPP2 :: (Doc Void -> Doc Void -> Doc Void) -> Doc -> Doc -> Doc
liftSep :: ([Doc Void] -> Doc Void) -> [Doc] -> Doc
(<.>) :: Doc -> Doc -> Doc
infixl 6 <.>
(<+>) :: Doc -> Doc -> Doc
infixl 6 <+>
() :: Doc -> Doc -> Doc
infixl 6
($$) :: Doc -> Doc -> Doc
infixl 5 $$
sep :: [Doc] -> Doc
fsep :: [Doc] -> Doc
hsep :: [Doc] -> Doc
hcat :: [Doc] -> Doc
vcat :: [Doc] -> Doc
vsep :: [Doc] -> Doc
group :: Doc -> Doc
hang :: Doc -> Int -> Doc -> Doc
nest :: Int -> Doc -> Doc
indent :: Int -> Doc -> Doc
align :: Doc -> Doc
parens :: Doc -> Doc
braces :: Doc -> Doc
brackets :: Doc -> Doc
quotes :: Doc -> Doc
commaSep :: [Doc] -> Doc
-- | Print a comma-separated list. Lay out each item on a single line if it
-- will fit. If an item requires multiple lines, then start it on its own
-- line.
commaSepFill :: [Doc] -> Doc
ppList :: [Doc] -> Doc
ppTuple :: [Doc] -> Doc
ppRecord :: [Doc] -> Doc
backticks :: Doc -> Doc
text :: String -> Doc
char :: Char -> Doc
integer :: Integer -> Doc
int :: Int -> Doc
comma :: Doc
colon :: Doc
instance GHC.Show.Show Cryptol.Utils.PP.PPFloatExp
instance GHC.Show.Show Cryptol.Utils.PP.PPFloatFormat
instance GHC.Show.Show Cryptol.Utils.PP.FieldOrder
instance GHC.Read.Read Cryptol.Utils.PP.FieldOrder
instance GHC.Classes.Ord Cryptol.Utils.PP.FieldOrder
instance GHC.Classes.Eq Cryptol.Utils.PP.FieldOrder
instance GHC.Enum.Enum Cryptol.Utils.PP.FieldOrder
instance GHC.Enum.Bounded Cryptol.Utils.PP.FieldOrder
instance GHC.Show.Show Cryptol.Utils.PP.PPOpts
instance GHC.Show.Show Cryptol.Utils.PP.NameFormat
instance Control.DeepSeq.NFData Cryptol.Utils.PP.NameDisp
instance GHC.Generics.Generic Cryptol.Utils.PP.NameDisp
instance Control.DeepSeq.NFData Cryptol.Utils.PP.Doc
instance GHC.Generics.Generic Cryptol.Utils.PP.Doc
instance Cryptol.Utils.PP.PPName Cryptol.Utils.Ident.ModName
instance Cryptol.Utils.PP.PP Data.Text.Internal.Text
instance Cryptol.Utils.PP.PP Cryptol.Utils.Ident.Ident
instance Cryptol.Utils.PP.PP Cryptol.Utils.Ident.ModName
instance Cryptol.Utils.PP.PP Cryptol.Utils.Fixity.Assoc
instance Cryptol.Utils.PP.PP Cryptol.Utils.Fixity.Fixity
instance Cryptol.Utils.PP.PP Cryptol.Utils.Ident.ModPath
instance Cryptol.Utils.PP.PP Cryptol.Utils.Ident.OrigName
instance Cryptol.Utils.PP.PP Cryptol.Utils.Ident.Namespace
instance GHC.Base.Semigroup Cryptol.Utils.PP.Doc
instance GHC.Base.Monoid Cryptol.Utils.PP.Doc
instance GHC.Show.Show Cryptol.Utils.PP.Doc
instance Data.String.IsString Cryptol.Utils.PP.Doc
instance GHC.Show.Show Cryptol.Utils.PP.NameDisp
instance GHC.Base.Semigroup Cryptol.Utils.PP.NameDisp
instance GHC.Base.Monoid Cryptol.Utils.PP.NameDisp
module Cryptol.Utils.Debug
trace :: String -> b -> b
ppTrace :: Doc -> b -> b
module Cryptol.TypeCheck.PP
type NameMap = IntMap String
-- | This packages together a type with some names to be used to display
-- the variables. It is used for pretty printing types.
data WithNames a
WithNames :: a -> NameMap -> WithNames a
emptyNameMap :: NameMap
ppWithNamesPrec :: PP (WithNames a) => NameMap -> Int -> a -> Doc
ppWithNames :: PP (WithNames a) => NameMap -> a -> Doc
-- | Expand a list of base names into an infinite list of variations.
nameList :: [String] -> [String]
dump :: PP (WithNames a) => a -> String
module Cryptol.Parser.Token
data Token
Token :: !TokenT -> !Text -> Token
[tokenType] :: Token -> !TokenT
[tokenText] :: Token -> !Text
-- | Virtual tokens, inserted by layout processing.
data TokenV
VCurlyL :: TokenV
VCurlyR :: TokenV
VSemi :: TokenV
data TokenW
BlockComment :: TokenW
LineComment :: TokenW
Space :: TokenW
DocStr :: TokenW
data TokenKW
KW_else :: TokenKW
KW_extern :: TokenKW
KW_fin :: TokenKW
KW_if :: TokenKW
KW_private :: TokenKW
KW_include :: TokenKW
KW_inf :: TokenKW
KW_lg2 :: TokenKW
KW_lengthFromThen :: TokenKW
KW_lengthFromThenTo :: TokenKW
KW_max :: TokenKW
KW_min :: TokenKW
KW_module :: TokenKW
KW_submodule :: TokenKW
KW_newtype :: TokenKW
KW_pragma :: TokenKW
KW_property :: TokenKW
KW_then :: TokenKW
KW_type :: TokenKW
KW_where :: TokenKW
KW_let :: TokenKW
KW_x :: TokenKW
KW_import :: TokenKW
KW_as :: TokenKW
KW_hiding :: TokenKW
KW_infixl :: TokenKW
KW_infixr :: TokenKW
KW_infix :: TokenKW
KW_primitive :: TokenKW
KW_parameter :: TokenKW
KW_constraint :: TokenKW
KW_Prop :: TokenKW
KW_by :: TokenKW
KW_down :: TokenKW
-- | The named operators are a special case for parsing types, and
-- Other is used for all other cases that lexed as an operator.
data TokenOp
Plus :: TokenOp
Minus :: TokenOp
Mul :: TokenOp
Div :: TokenOp
Exp :: TokenOp
Mod :: TokenOp
Equal :: TokenOp
LEQ :: TokenOp
GEQ :: TokenOp
Complement :: TokenOp
Hash :: TokenOp
At :: TokenOp
Other :: [Text] -> Text -> TokenOp
data TokenSym
Bar :: TokenSym
ArrL :: TokenSym
ArrR :: TokenSym
FatArrR :: TokenSym
Lambda :: TokenSym
EqDef :: TokenSym
Comma :: TokenSym
Semi :: TokenSym
Dot :: TokenSym
DotDot :: TokenSym
DotDotDot :: TokenSym
DotDotLt :: TokenSym
DotDotGt :: TokenSym
Colon :: TokenSym
BackTick :: TokenSym
ParenL :: TokenSym
ParenR :: TokenSym
BracketL :: TokenSym
BracketR :: TokenSym
CurlyL :: TokenSym
CurlyR :: TokenSym
TriL :: TokenSym
TriR :: TokenSym
Lt :: TokenSym
Gt :: TokenSym
Underscore :: TokenSym
data TokenErr
UnterminatedComment :: TokenErr
UnterminatedString :: TokenErr
UnterminatedChar :: TokenErr
InvalidString :: TokenErr
InvalidChar :: TokenErr
LexicalError :: TokenErr
MalformedLiteral :: TokenErr
MalformedSelector :: TokenErr
InvalidIndentation :: TokenT -> TokenErr
data SelectorType
RecordSelectorTok :: Text -> SelectorType
TupleSelectorTok :: Int -> SelectorType
data TokenT
-- | value, base, number of digits
Num :: !Integer -> !Int -> !Int -> TokenT
-- | value, base.
Frac :: !Rational -> !Int -> TokenT
-- | character literal
ChrLit :: !Char -> TokenT
-- | (qualified) identifier
Ident :: ![Text] -> !Text -> TokenT
-- | string literal
StrLit :: !String -> TokenT
-- | .hello or .123
Selector :: !SelectorType -> TokenT
-- | keyword
KW :: !TokenKW -> TokenT
-- | operator
Op :: !TokenOp -> TokenT
-- | symbol
Sym :: !TokenSym -> TokenT
-- | virtual token (for layout)
Virt :: !TokenV -> TokenT
-- | white space token
White :: !TokenW -> TokenT
-- | error token
Err :: !TokenErr -> TokenT
EOF :: TokenT
instance Control.DeepSeq.NFData Cryptol.Parser.Token.TokenV
instance GHC.Generics.Generic Cryptol.Parser.Token.TokenV
instance GHC.Show.Show Cryptol.Parser.Token.TokenV
instance GHC.Classes.Eq Cryptol.Parser.Token.TokenV
instance Control.DeepSeq.NFData Cryptol.Parser.Token.TokenW
instance GHC.Generics.Generic Cryptol.Parser.Token.TokenW
instance GHC.Show.Show Cryptol.Parser.Token.TokenW
instance GHC.Classes.Eq Cryptol.Parser.Token.TokenW
instance Control.DeepSeq.NFData Cryptol.Parser.Token.TokenKW
instance GHC.Generics.Generic Cryptol.Parser.Token.TokenKW
instance GHC.Show.Show Cryptol.Parser.Token.TokenKW
instance GHC.Classes.Eq Cryptol.Parser.Token.TokenKW
instance Control.DeepSeq.NFData Cryptol.Parser.Token.TokenOp
instance GHC.Generics.Generic Cryptol.Parser.Token.TokenOp
instance GHC.Show.Show Cryptol.Parser.Token.TokenOp
instance GHC.Classes.Eq Cryptol.Parser.Token.TokenOp
instance Control.DeepSeq.NFData Cryptol.Parser.Token.TokenSym
instance GHC.Generics.Generic Cryptol.Parser.Token.TokenSym
instance GHC.Show.Show Cryptol.Parser.Token.TokenSym
instance GHC.Classes.Eq Cryptol.Parser.Token.TokenSym
instance Control.DeepSeq.NFData Cryptol.Parser.Token.SelectorType
instance GHC.Generics.Generic Cryptol.Parser.Token.SelectorType
instance GHC.Show.Show Cryptol.Parser.Token.SelectorType
instance GHC.Classes.Eq Cryptol.Parser.Token.SelectorType
instance Control.DeepSeq.NFData Cryptol.Parser.Token.TokenErr
instance GHC.Generics.Generic Cryptol.Parser.Token.TokenErr
instance GHC.Show.Show Cryptol.Parser.Token.TokenErr
instance GHC.Classes.Eq Cryptol.Parser.Token.TokenErr
instance Control.DeepSeq.NFData Cryptol.Parser.Token.TokenT
instance GHC.Generics.Generic Cryptol.Parser.Token.TokenT
instance GHC.Show.Show Cryptol.Parser.Token.TokenT
instance GHC.Classes.Eq Cryptol.Parser.Token.TokenT
instance Control.DeepSeq.NFData Cryptol.Parser.Token.Token
instance GHC.Generics.Generic Cryptol.Parser.Token.Token
instance GHC.Show.Show Cryptol.Parser.Token.Token
instance Cryptol.Utils.PP.PP Cryptol.Parser.Token.Token
module Cryptol.Parser.Selector
-- | Selectors are used for projecting from various components. Each
-- selector has an option spec to specify the shape of the thing that is
-- being selected. Currently, there is no surface syntax for list
-- selectors, but they are used during the desugaring of patterns.
data Selector
-- | Zero-based tuple selection. Optionally specifies the shape of the
-- tuple (one-based).
TupleSel :: Int -> Maybe Int -> Selector
-- | Record selection. Optionally specifies the shape of the record.
RecordSel :: Ident -> Maybe [Ident] -> Selector
-- | List selection. Optionally specifies the length of the list.
ListSel :: Int -> Maybe Int -> Selector
-- | Display the thing selected by the selector, nicely.
ppSelector :: Selector -> Doc
-- | Show a list of selectors as they appear in a nested selector in an
-- update.
ppNestedSels :: [Selector] -> Doc
-- | The name of a selector (e.g., used in update code)
selName :: Selector -> Ident
instance Control.DeepSeq.NFData Cryptol.Parser.Selector.Selector
instance GHC.Generics.Generic Cryptol.Parser.Selector.Selector
instance GHC.Classes.Ord Cryptol.Parser.Selector.Selector
instance GHC.Show.Show Cryptol.Parser.Selector.Selector
instance GHC.Classes.Eq Cryptol.Parser.Selector.Selector
instance Cryptol.Utils.PP.PP Cryptol.Parser.Selector.Selector
module Cryptol.Parser.Position
data Located a
Located :: !Range -> !a -> Located a
[srcRange] :: Located a -> !Range
[thing] :: Located a -> !a
data Position
Position :: !Int -> !Int -> Position
[line] :: Position -> !Int
[col] :: Position -> !Int
data Range
Range :: !Position -> !Position -> FilePath -> Range
[from] :: Range -> !Position
[to] :: Range -> !Position
[source] :: Range -> FilePath
-- | An empty range.
--
-- Caution: using this on the LHS of a use of rComb will cause the empty
-- source to propagate.
emptyRange :: Range
start :: Position
move :: Position -> Char -> Position
moves :: Position -> Text -> Position
rComb :: Range -> Range -> Range
rCombMaybe :: Maybe Range -> Maybe Range -> Maybe Range
rCombs :: [Range] -> Range
class HasLoc t
getLoc :: HasLoc t => t -> Maybe Range
class HasLoc t => AddLoc t
addLoc :: AddLoc t => t -> Range -> t
dropLoc :: AddLoc t => t -> t
at :: (HasLoc l, AddLoc t) => l -> t -> t
combLoc :: (a -> b -> c) -> Located a -> Located b -> Located c
instance Control.DeepSeq.NFData Cryptol.Parser.Position.Position
instance GHC.Generics.Generic Cryptol.Parser.Position.Position
instance GHC.Show.Show Cryptol.Parser.Position.Position
instance GHC.Classes.Ord Cryptol.Parser.Position.Position
instance GHC.Classes.Eq Cryptol.Parser.Position.Position
instance Control.DeepSeq.NFData Cryptol.Parser.Position.Range
instance GHC.Generics.Generic Cryptol.Parser.Position.Range
instance GHC.Show.Show Cryptol.Parser.Position.Range
instance GHC.Classes.Ord Cryptol.Parser.Position.Range
instance GHC.Classes.Eq Cryptol.Parser.Position.Range
instance Data.Traversable.Traversable Cryptol.Parser.Position.Located
instance Data.Foldable.Foldable Cryptol.Parser.Position.Located
instance GHC.Base.Functor Cryptol.Parser.Position.Located
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Cryptol.Parser.Position.Located a)
instance GHC.Generics.Generic (Cryptol.Parser.Position.Located a)
instance GHC.Show.Show a => GHC.Show.Show (Cryptol.Parser.Position.Located a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Cryptol.Parser.Position.Located a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Cryptol.Parser.Position.Located a)
instance Cryptol.Parser.Position.AddLoc (Cryptol.Parser.Position.Located a)
instance Cryptol.Parser.Position.HasLoc Cryptol.Parser.Position.Range
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.Position.Located a)
instance (Cryptol.Parser.Position.HasLoc a, Cryptol.Parser.Position.HasLoc b) => Cryptol.Parser.Position.HasLoc (a, b)
instance Cryptol.Parser.Position.HasLoc a => Cryptol.Parser.Position.HasLoc [a]
instance Cryptol.Utils.PP.PP a => Cryptol.Utils.PP.PP (Cryptol.Parser.Position.Located a)
instance Cryptol.Utils.PP.PPName a => Cryptol.Utils.PP.PPName (Cryptol.Parser.Position.Located a)
instance Cryptol.Utils.PP.PP Cryptol.Parser.Position.Range
instance Cryptol.Utils.PP.PP Cryptol.Parser.Position.Position
module Cryptol.Utils.Panic
-- | Request a CallStack.
--
-- NOTE: The implicit parameter ?callStack :: CallStack is an
-- implementation detail and should not be considered part of the
-- CallStack API, we may decide to change the implementation in
-- the future.
type HasCallStack = ?callStack :: CallStack
type CryptolPanic = Panic Cryptol
data Cryptol
-- | The exception thrown when panicing.
data Panic a
panic :: HasCallStack => String -> [String] -> a
instance Panic.PanicComponent Cryptol.Utils.Panic.Cryptol
-- | This module defines natural numbers with an additional infinity
-- element, and various arithmetic operators on them.
module Cryptol.TypeCheck.Solver.InfNat
-- | Natural numbers with an infinity element
data Nat'
Nat :: Integer -> Nat'
Inf :: Nat'
fromNat :: Nat' -> Maybe Integer
nAdd :: Nat' -> Nat' -> Nat'
-- | Some algebraic properties of interest:
--
--
-- 1 * x = x
-- x * (y * z) = (x * y) * z
-- 0 * x = 0
-- x * y = y * x
-- x * (a + b) = x * a + x * b
--
nMul :: Nat' -> Nat' -> Nat'
-- | Some algebraic properties of interest:
--
--
-- x ^ 0 = 1
-- x ^ (n + 1) = x * (x ^ n)
-- x ^ (m + n) = (x ^ m) * (x ^ n)
-- x ^ (m * n) = (x ^ m) ^ n
--
nExp :: Nat' -> Nat' -> Nat'
nMin :: Nat' -> Nat' -> Nat'
nMax :: Nat' -> Nat' -> Nat'
-- | nSub x y = Just z iff z is the unique value such
-- that Add y z = Just x.
nSub :: Nat' -> Nat' -> Maybe Nat'
-- | Rounds down.
--
--
-- y * q + r = x
-- x / y = q with remainder r
-- 0 <= r && r < y
--
--
-- We don't allow Inf in the first argument for two reasons: 1. It
-- matches the behavior of nMod, 2. The well-formedness
-- constraints can be expressed as a conjunction.
nDiv :: Nat' -> Nat' -> Maybe Nat'
nMod :: Nat' -> Nat' -> Maybe Nat'
-- | nCeilDiv msgLen blockSize computes the least n such
-- that msgLen <= blockSize * n. It is undefined when
-- blockSize = 0, or when blockSize = inf. inf
-- divided by any positive finite value is inf.
nCeilDiv :: Nat' -> Nat' -> Maybe Nat'
-- | nCeilMod msgLen blockSize computes the least k such
-- that blockSize divides msgLen + k. It is undefined
-- when blockSize = 0 or blockSize = inf. inf
-- modulus any positive finite value is 0.
nCeilMod :: Nat' -> Nat' -> Maybe Nat'
-- | Rounds up. lg2 x = y, iff y is the smallest number
-- such that x <= 2 ^ y
nLg2 :: Nat' -> Nat'
-- | nWidth n is number of bits needed to represent all numbers
-- from 0 to n, inclusive. nWidth x = nLg2 (x + 1).
nWidth :: Nat' -> Nat'
-- |
-- length [ x, y .. z ]
--
nLenFromThenTo :: Nat' -> Nat' -> Nat' -> Maybe Nat'
-- | Compute the logarithm of a number in the given base, rounded down to
-- the closest integer. The boolean indicates if we the result is exact
-- (i.e., True means no rounding happened, False means we rounded down).
-- The logarithm base is the second argument.
genLog :: Integer -> Integer -> Maybe (Integer, Bool)
-- | Compute the number of bits required to represent the given integer.
widthInteger :: Integer -> Integer
-- | Compute the exact root of a natural number. The second argument
-- specifies which root we are computing.
rootExact :: Integer -> Integer -> Maybe Integer
-- | Compute the the n-th root of a natural number, rounded down to the
-- closest natural number. The boolean indicates if the result is exact
-- (i.e., True means no rounding was done, False means rounded down). The
-- second argument specifies which root we are computing.
genRoot :: Integer -> Integer -> Maybe (Integer, Bool)
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Solver.InfNat.Nat'
instance GHC.Generics.Generic Cryptol.TypeCheck.Solver.InfNat.Nat'
instance GHC.Classes.Ord Cryptol.TypeCheck.Solver.InfNat.Nat'
instance GHC.Classes.Eq Cryptol.TypeCheck.Solver.InfNat.Nat'
instance GHC.Show.Show Cryptol.TypeCheck.Solver.InfNat.Nat'
module Cryptol.F2
pmult :: Int -> Integer -> Integer -> Integer
pdiv :: Int -> Integer -> Integer -> Integer
pmod :: Int -> Integer -> Integer -> Integer
module Cryptol.REPL.Trie
-- | Maps string names to values, allowing for partial key matches and
-- querying.
data Trie a
Node :: Map Char (Trie a) -> Maybe a -> Trie a
emptyTrie :: Trie a
-- | Insert a value into the Trie, forcing the key value to lower case.
-- Will call panic if a value already exists with that key.
insertTrie :: String -> a -> Trie a -> Trie a
-- | Return all matches with the given prefix.
lookupTrie :: String -> Trie a -> [a]
-- | Given a key, return either an exact match for that key, or all matches
-- with the given prefix.
lookupTrieExact :: String -> Trie a -> [a]
-- | Return all of the values from a Trie.
leaves :: Trie a -> [a]
instance GHC.Show.Show a => GHC.Show.Show (Cryptol.REPL.Trie.Trie a)
-- | Convert a literate source file into an ordinary source file.
module Cryptol.Parser.Unlit
unLit :: PreProc -> Text -> Text
data PreProc
None :: PreProc
Markdown :: PreProc
LaTeX :: PreProc
guessPreProc :: FilePath -> PreProc
knownExts :: [String]
module Cryptol.Parser.Name
-- | Names that originate in the parser.
data PName
-- | Unqualified names like x, Foo, or +.
UnQual :: !Ident -> PName
-- | Qualified names like Foo::bar or module::!.
Qual :: !ModName -> !Ident -> PName
-- | Fresh names generated by a pass.
NewName :: !Pass -> !Int -> PName
-- | Passes that can generate fresh names.
data Pass
NoPat :: Pass
MonoValues :: Pass
mkUnqual :: Ident -> PName
mkQual :: ModName -> Ident -> PName
getModName :: PName -> Maybe ModName
getIdent :: PName -> Ident
isGeneratedName :: PName -> Bool
instance GHC.Generics.Generic Cryptol.Parser.Name.Pass
instance GHC.Show.Show Cryptol.Parser.Name.Pass
instance GHC.Classes.Ord Cryptol.Parser.Name.Pass
instance GHC.Classes.Eq Cryptol.Parser.Name.Pass
instance GHC.Generics.Generic Cryptol.Parser.Name.PName
instance GHC.Show.Show Cryptol.Parser.Name.PName
instance GHC.Classes.Ord Cryptol.Parser.Name.PName
instance GHC.Classes.Eq Cryptol.Parser.Name.PName
instance Control.DeepSeq.NFData Cryptol.Parser.Name.PName
instance Cryptol.Utils.PP.PP Cryptol.Parser.Name.PName
instance Cryptol.Utils.PP.PPName Cryptol.Parser.Name.PName
instance Control.DeepSeq.NFData Cryptol.Parser.Name.Pass
module Cryptol.Parser.Layout
layout :: Bool -> [Located Token] -> [Located Token]
data Block
-- | Virtual layout block
Virtual :: Int -> Block
-- | An explicit layout block, expecting this ending token.
Explicit :: TokenT -> Block
-- | These tokens start an implicit layout block
startsLayout :: TokenT -> Bool
-- | These tokens end an implicit layout block
endsLayout :: TokenT -> Bool
-- | These tokens start an explicit "paren" layout block. If so, the result
-- contains the corresponding closing paren.
startsParenBlock :: TokenT -> Maybe TokenT
-- | Make a virtual token of the given type
virt :: Range -> TokenV -> Located Token
errTok :: Range -> TokenErr -> Located Token
instance GHC.Show.Show Cryptol.Parser.Layout.Block
-- | At present Alex generates code with too many warnings.
module Cryptol.Parser.Lexer
-- | Returns the tokens and the last position of the input that we
-- processed. The tokens include whte space tokens.
primLexer :: Config -> Text -> ([Located Token], Position)
-- | Returns the tokens in the last position of the input that we
-- processed. White space is removed, and layout processing is done as
-- requested. This stream is fed to the parser.
lexer :: Config -> Text -> ([Located Token], Position)
data Layout
Layout :: Layout
NoLayout :: Layout
data Token
Token :: !TokenT -> !Text -> Token
[tokenType] :: Token -> !TokenT
[tokenText] :: Token -> !Text
data TokenT
-- | value, base, number of digits
Num :: !Integer -> !Int -> !Int -> TokenT
-- | value, base.
Frac :: !Rational -> !Int -> TokenT
-- | character literal
ChrLit :: !Char -> TokenT
-- | (qualified) identifier
Ident :: ![Text] -> !Text -> TokenT
-- | string literal
StrLit :: !String -> TokenT
-- | .hello or .123
Selector :: !SelectorType -> TokenT
-- | keyword
KW :: !TokenKW -> TokenT
-- | operator
Op :: !TokenOp -> TokenT
-- | symbol
Sym :: !TokenSym -> TokenT
-- | virtual token (for layout)
Virt :: !TokenV -> TokenT
-- | white space token
White :: !TokenW -> TokenT
-- | error token
Err :: !TokenErr -> TokenT
EOF :: TokenT
-- | Virtual tokens, inserted by layout processing.
data TokenV
VCurlyL :: TokenV
VCurlyR :: TokenV
VSemi :: TokenV
data TokenKW
KW_else :: TokenKW
KW_extern :: TokenKW
KW_fin :: TokenKW
KW_if :: TokenKW
KW_private :: TokenKW
KW_include :: TokenKW
KW_inf :: TokenKW
KW_lg2 :: TokenKW
KW_lengthFromThen :: TokenKW
KW_lengthFromThenTo :: TokenKW
KW_max :: TokenKW
KW_min :: TokenKW
KW_module :: TokenKW
KW_submodule :: TokenKW
KW_newtype :: TokenKW
KW_pragma :: TokenKW
KW_property :: TokenKW
KW_then :: TokenKW
KW_type :: TokenKW
KW_where :: TokenKW
KW_let :: TokenKW
KW_x :: TokenKW
KW_import :: TokenKW
KW_as :: TokenKW
KW_hiding :: TokenKW
KW_infixl :: TokenKW
KW_infixr :: TokenKW
KW_infix :: TokenKW
KW_primitive :: TokenKW
KW_parameter :: TokenKW
KW_constraint :: TokenKW
KW_Prop :: TokenKW
KW_by :: TokenKW
KW_down :: TokenKW
data TokenErr
UnterminatedComment :: TokenErr
UnterminatedString :: TokenErr
UnterminatedChar :: TokenErr
InvalidString :: TokenErr
InvalidChar :: TokenErr
LexicalError :: TokenErr
MalformedLiteral :: TokenErr
MalformedSelector :: TokenErr
InvalidIndentation :: TokenT -> TokenErr
data TokenSym
Bar :: TokenSym
ArrL :: TokenSym
ArrR :: TokenSym
FatArrR :: TokenSym
Lambda :: TokenSym
EqDef :: TokenSym
Comma :: TokenSym
Semi :: TokenSym
Dot :: TokenSym
DotDot :: TokenSym
DotDotDot :: TokenSym
DotDotLt :: TokenSym
DotDotGt :: TokenSym
Colon :: TokenSym
BackTick :: TokenSym
ParenL :: TokenSym
ParenR :: TokenSym
BracketL :: TokenSym
BracketR :: TokenSym
CurlyL :: TokenSym
CurlyR :: TokenSym
TriL :: TokenSym
TriR :: TokenSym
Lt :: TokenSym
Gt :: TokenSym
Underscore :: TokenSym
data TokenW
BlockComment :: TokenW
LineComment :: TokenW
Space :: TokenW
DocStr :: TokenW
data Located a
Located :: !Range -> !a -> Located a
[srcRange] :: Located a -> !Range
[thing] :: Located a -> !a
data Config
Config :: !FilePath -> !Position -> !Layout -> PreProc -> [FilePath] -> Bool -> Config
-- | File that we are working on
[cfgSource] :: Config -> !FilePath
-- | Starting position for the parser
[cfgStart] :: Config -> !Position
-- | Settings for layout processing
[cfgLayout] :: Config -> !Layout
-- | Preprocessor settings
[cfgPreProc] :: Config -> PreProc
-- | Implicit includes
[cfgAutoInclude] :: Config -> [FilePath]
-- | When we do layout processing should we add a vCurly (i.e., are we
-- parsing a list of things).
[cfgModuleScope] :: Config -> Bool
defaultConfig :: Config
dbgLex :: FilePath -> IO ()
module Cryptol.ModuleSystem.Name
data Name
-- | Information about the binding site of the name.
data NameInfo
-- | This name refers to a declaration from this module
Declared :: !ModPath -> !NameSource -> NameInfo
-- | This name is a parameter (function or type)
Parameter :: NameInfo
data NameSource
SystemName :: NameSource
UserName :: NameSource
nameUnique :: Name -> Int
nameIdent :: Name -> Ident
nameInfo :: Name -> NameInfo
nameLoc :: Name -> Range
nameFixity :: Name -> Maybe Fixity
nameNamespace :: Name -> Namespace
-- | Primtiives must be in a top level module, at least for now.
asPrim :: Name -> Maybe PrimIdent
asOrigName :: Name -> Maybe OrigName
-- | Pretty-print a name with its source location information.
ppLocName :: Name -> Doc
-- | Namespaces for names
data Namespace
NSValue :: Namespace
NSType :: Namespace
NSModule :: Namespace
-- | Idnetifies a possibly nested module
data ModPath
TopModule :: ModName -> ModPath
Nested :: ModPath -> Ident -> ModPath
-- | Compare two names by the way they would be displayed. This is used to
-- order names nicely when showing what's in scope
cmpNameDisplay :: NameDisp -> Name -> Name -> Ordering
-- | Make a new name for a declaration.
mkDeclared :: Namespace -> ModPath -> NameSource -> Ident -> Maybe Fixity -> Range -> Supply -> (Name, Supply)
-- | Make a new parameter name.
mkParameter :: Namespace -> Ident -> Range -> Supply -> (Name, Supply)
toParamInstName :: Name -> Name
asParamName :: Name -> Name
paramModRecParam :: Name
class Monad m => FreshM m
liftSupply :: FreshM m => (Supply -> (a, Supply)) -> m a
-- | Retrieve the next unique from the supply.
nextUniqueM :: FreshM m => m Int
-- | A monad for easing the use of the supply.
data SupplyT m a
runSupplyT :: Monad m => Supply -> SupplyT m a -> m (a, Supply)
data Supply
-- | This should only be used once at library initialization, and threaded
-- through the rest of the session. The supply is started at 0x1000 to
-- leave us plenty of room for names that the compiler needs to know
-- about (wired-in constants).
emptySupply :: Supply
nextUnique :: Supply -> (Int, Supply)
-- | A mapping from an identifier defined in some module to its real name.
data PrimMap
PrimMap :: Map PrimIdent Name -> Map PrimIdent Name -> PrimMap
[primDecls] :: PrimMap -> Map PrimIdent Name
[primTypes] :: PrimMap -> Map PrimIdent Name
-- | It's assumed that we're looking things up that we know already exist,
-- so this will panic if it doesn't find the name.
lookupPrimDecl :: PrimIdent -> PrimMap -> Name
-- | It's assumed that we're looking things up that we know already exist,
-- so this will panic if it doesn't find the name.
lookupPrimType :: PrimIdent -> PrimMap -> Name
instance GHC.Classes.Eq Cryptol.ModuleSystem.Name.NameSource
instance GHC.Show.Show Cryptol.ModuleSystem.Name.NameSource
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Name.NameSource
instance GHC.Generics.Generic Cryptol.ModuleSystem.Name.NameSource
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Name.NameInfo
instance GHC.Generics.Generic Cryptol.ModuleSystem.Name.NameInfo
instance GHC.Show.Show Cryptol.ModuleSystem.Name.NameInfo
instance GHC.Classes.Eq Cryptol.ModuleSystem.Name.NameInfo
instance GHC.Show.Show Cryptol.ModuleSystem.Name.Name
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Name.Name
instance GHC.Generics.Generic Cryptol.ModuleSystem.Name.Name
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Name.Supply
instance GHC.Generics.Generic Cryptol.ModuleSystem.Name.Supply
instance GHC.Show.Show Cryptol.ModuleSystem.Name.Supply
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Name.PrimMap
instance GHC.Generics.Generic Cryptol.ModuleSystem.Name.PrimMap
instance GHC.Show.Show Cryptol.ModuleSystem.Name.PrimMap
instance GHC.Base.Semigroup Cryptol.ModuleSystem.Name.PrimMap
instance Cryptol.ModuleSystem.Name.FreshM m => Cryptol.ModuleSystem.Name.FreshM (MonadLib.ExceptionT i m)
instance (GHC.Base.Monoid i, Cryptol.ModuleSystem.Name.FreshM m) => Cryptol.ModuleSystem.Name.FreshM (MonadLib.WriterT i m)
instance Cryptol.ModuleSystem.Name.FreshM m => Cryptol.ModuleSystem.Name.FreshM (MonadLib.ReaderT i m)
instance Cryptol.ModuleSystem.Name.FreshM m => Cryptol.ModuleSystem.Name.FreshM (MonadLib.StateT i m)
instance GHC.Base.Monad m => Cryptol.ModuleSystem.Name.FreshM (Cryptol.ModuleSystem.Name.SupplyT m)
instance GHC.Base.Monad m => GHC.Base.Functor (Cryptol.ModuleSystem.Name.SupplyT m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Cryptol.ModuleSystem.Name.SupplyT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Cryptol.ModuleSystem.Name.SupplyT m)
instance MonadLib.MonadT Cryptol.ModuleSystem.Name.SupplyT
instance MonadLib.BaseM m n => MonadLib.BaseM (Cryptol.ModuleSystem.Name.SupplyT m) n
instance MonadLib.RunM m (a, Cryptol.ModuleSystem.Name.Supply) r => MonadLib.RunM (Cryptol.ModuleSystem.Name.SupplyT m) a (Cryptol.ModuleSystem.Name.Supply -> r)
instance GHC.Classes.Eq Cryptol.ModuleSystem.Name.Name
instance GHC.Classes.Ord Cryptol.ModuleSystem.Name.Name
instance Cryptol.Utils.PP.PP Cryptol.ModuleSystem.Name.Name
instance Cryptol.Utils.PP.PPName Cryptol.ModuleSystem.Name.Name
module Cryptol.TypeCheck.TCon
-- | This is used for pretty prinitng. XXX: it would be nice to just rely
-- in the info from the Prelude.
infixPrimTy :: TCon -> Maybe (Ident, Fixity)
builtInType :: Name -> Maybe TCon
-- | Kinds, classify types.
data Kind
KType :: Kind
KNum :: Kind
KProp :: Kind
(:->) :: Kind -> Kind -> Kind
infixr 5 :->
class HasKind t
kindOf :: HasKind t => t -> Kind
-- | Type constants.
data TCon
TC :: TC -> TCon
PC :: PC -> TCon
TF :: TFun -> TCon
TError :: Kind -> TCon
-- | Predicate symbols. If you add additional user-visible constructors,
-- please update primTys.
data PC
-- |
-- _ == _
--
PEqual :: PC
-- |
-- _ /= _
--
PNeq :: PC
-- |
-- _ >= _
--
PGeq :: PC
-- |
-- fin _
--
PFin :: PC
-- |
-- prime _
--
PPrime :: PC
-- | Has sel type field does not appear in schemas
PHas :: Selector -> PC
-- |
-- Zero _
--
PZero :: PC
-- |
-- Logic _
--
PLogic :: PC
-- |
-- Ring _
--
PRing :: PC
-- |
-- Integral _
--
PIntegral :: PC
-- |
-- Field _
--
PField :: PC
-- |
-- Round _
--
PRound :: PC
-- |
-- Eq _
--
PEq :: PC
-- |
-- Cmp _
--
PCmp :: PC
-- |
-- SignedCmp _
--
PSignedCmp :: PC
-- |
-- Literal _ _
--
PLiteral :: PC
-- |
-- LiteralLessThan _ _
--
PLiteralLessThan :: PC
-- |
-- FLiteral _ _ _
--
PFLiteral :: PC
-- | ValidFloat _ _ constraints on supported floating point
-- representaitons
PValidFloat :: PC
-- | This is useful when simplifying things in place
PAnd :: PC
-- | Ditto
PTrue :: PC
-- | 1-1 constants. If you add additional user-visible constructors, please
-- update primTys.
data TC
-- | Numbers
TCNum :: Integer -> TC
-- | Inf
TCInf :: TC
-- | Bit
TCBit :: TC
-- | Integer
TCInteger :: TC
-- | Float
TCFloat :: TC
-- |
-- Z _
--
TCIntMod :: TC
-- |
-- Rational
--
TCRational :: TC
-- |
-- Array _ _
--
TCArray :: TC
-- |
-- [_] _
--
TCSeq :: TC
-- |
-- _ -> _
--
TCFun :: TC
-- |
-- (_, _, _)
--
TCTuple :: Int -> TC
-- | An abstract type
TCAbstract :: UserTC -> TC
data UserTC
UserTC :: Name -> Kind -> UserTC
-- | Built-in type functions. If you add additional user-visible
-- constructors, please update primTys in
-- Cryptol.Prims.Types.
data TFun
-- |
-- : Num -> Num -> Num
--
TCAdd :: TFun
-- |
-- : Num -> Num -> Num
--
TCSub :: TFun
-- |
-- : Num -> Num -> Num
--
TCMul :: TFun
-- |
-- : Num -> Num -> Num
--
TCDiv :: TFun
-- |
-- : Num -> Num -> Num
--
TCMod :: TFun
-- |
-- : Num -> Num -> Num
--
TCExp :: TFun
-- |
-- : Num -> Num
--
TCWidth :: TFun
-- |
-- : Num -> Num -> Num
--
TCMin :: TFun
-- |
-- : Num -> Num -> Num
--
TCMax :: TFun
-- |
-- : Num -> Num -> Num
--
TCCeilDiv :: TFun
-- |
-- : Num -> Num -> Num
--
TCCeilMod :: TFun
-- | : Num -> Num -> Num -> Num Example: [ 1, 5 .. 9
-- ] :: [lengthFromThenTo 1 5 9][b]
TCLenFromThenTo :: TFun
instance Control.DeepSeq.NFData Cryptol.TypeCheck.TCon.Kind
instance GHC.Generics.Generic Cryptol.TypeCheck.TCon.Kind
instance GHC.Show.Show Cryptol.TypeCheck.TCon.Kind
instance GHC.Classes.Ord Cryptol.TypeCheck.TCon.Kind
instance GHC.Classes.Eq Cryptol.TypeCheck.TCon.Kind
instance Control.DeepSeq.NFData Cryptol.TypeCheck.TCon.PC
instance GHC.Generics.Generic Cryptol.TypeCheck.TCon.PC
instance GHC.Classes.Ord Cryptol.TypeCheck.TCon.PC
instance GHC.Classes.Eq Cryptol.TypeCheck.TCon.PC
instance GHC.Show.Show Cryptol.TypeCheck.TCon.PC
instance Control.DeepSeq.NFData Cryptol.TypeCheck.TCon.UserTC
instance GHC.Generics.Generic Cryptol.TypeCheck.TCon.UserTC
instance GHC.Show.Show Cryptol.TypeCheck.TCon.UserTC
instance Control.DeepSeq.NFData Cryptol.TypeCheck.TCon.TC
instance GHC.Generics.Generic Cryptol.TypeCheck.TCon.TC
instance GHC.Classes.Ord Cryptol.TypeCheck.TCon.TC
instance GHC.Classes.Eq Cryptol.TypeCheck.TCon.TC
instance GHC.Show.Show Cryptol.TypeCheck.TCon.TC
instance Control.DeepSeq.NFData Cryptol.TypeCheck.TCon.TFun
instance GHC.Generics.Generic Cryptol.TypeCheck.TCon.TFun
instance GHC.Enum.Enum Cryptol.TypeCheck.TCon.TFun
instance GHC.Enum.Bounded Cryptol.TypeCheck.TCon.TFun
instance GHC.Classes.Ord Cryptol.TypeCheck.TCon.TFun
instance GHC.Classes.Eq Cryptol.TypeCheck.TCon.TFun
instance GHC.Show.Show Cryptol.TypeCheck.TCon.TFun
instance Control.DeepSeq.NFData Cryptol.TypeCheck.TCon.TCon
instance GHC.Generics.Generic Cryptol.TypeCheck.TCon.TCon
instance GHC.Classes.Ord Cryptol.TypeCheck.TCon.TCon
instance GHC.Classes.Eq Cryptol.TypeCheck.TCon.TCon
instance GHC.Show.Show Cryptol.TypeCheck.TCon.TCon
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.TCon.TCon
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.TCon.TCon
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.TCon.TFun
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.TCon.TFun
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.TCon.TC
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.TCon.TC
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.TCon.UserTC
instance GHC.Classes.Eq Cryptol.TypeCheck.TCon.UserTC
instance GHC.Classes.Ord Cryptol.TypeCheck.TCon.UserTC
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.TCon.UserTC
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.TCon.PC
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.TCon.PC
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.TCon.Kind
module Cryptol.Utils.Patterns
newtype Match b
Match :: (forall r. r -> (b -> r) -> r) -> Match b
type Pat a b = a -> Match b
(|||) :: Pat a b -> Pat a b -> Pat a b
-- | Check that a value satisfies multiple patterns. For example, an "as"
-- pattern is (__ &&& p).
(&&&) :: Pat a b -> Pat a c -> Pat a (b, c)
-- | Match a value, and modify the result.
(~>) :: Pat a b -> (b -> c) -> Pat a c
-- | Match a value, and return the given result
(~~>) :: Pat a b -> c -> Pat a c
-- | View pattern.
(<~) :: (a -> b) -> Pat b c -> Pat a c
-- | Variable pattern.
__ :: Pat a a
-- | Constant pattern.
succeed :: a -> Pat x a
-- | Predicate pattern
checkThat :: (a -> Bool) -> Pat a ()
-- | Check for exact value.
lit :: Eq a => a -> Pat a ()
-- | Match a pattern, using the given default if valure.
matchDefault :: a -> Match a -> a
-- | Match an irrefutable pattern. Crashes on faliure.
match :: Match a -> a
matchMaybe :: Match a -> Maybe a
list :: [Pat a b] -> Pat [a] [b]
(><) :: Pat a b -> Pat x y -> Pat (a, x) (b, y)
class Matches thing pats res | pats -> thing res
matches :: Matches thing pats res => thing -> pats -> Match res
instance (f GHC.Types.~ Cryptol.Utils.Patterns.Pat a a1', a1 GHC.Types.~ Cryptol.Utils.Patterns.Pat a1' r1) => Cryptol.Utils.Patterns.Matches a (f, a1) r1
instance (op GHC.Types.~ Cryptol.Utils.Patterns.Pat a (a1', a2'), a1 GHC.Types.~ Cryptol.Utils.Patterns.Pat a1' r1, a2 GHC.Types.~ Cryptol.Utils.Patterns.Pat a2' r2) => Cryptol.Utils.Patterns.Matches a (op, a1, a2) (r1, r2)
instance (op GHC.Types.~ Cryptol.Utils.Patterns.Pat a (a1', a2', a3'), a1 GHC.Types.~ Cryptol.Utils.Patterns.Pat a1' r1, a2 GHC.Types.~ Cryptol.Utils.Patterns.Pat a2' r2, a3 GHC.Types.~ Cryptol.Utils.Patterns.Pat a3' r3) => Cryptol.Utils.Patterns.Matches a (op, a1, a2, a3) (r1, r2, r3)
instance GHC.Base.Functor Cryptol.Utils.Patterns.Match
instance GHC.Base.Applicative Cryptol.Utils.Patterns.Match
instance GHC.Base.Monad Cryptol.Utils.Patterns.Match
instance Control.Monad.Fail.MonadFail Cryptol.Utils.Patterns.Match
instance GHC.Base.Alternative Cryptol.Utils.Patterns.Match
instance GHC.Base.MonadPlus Cryptol.Utils.Patterns.Match
-- | This module implements an "order insensitive" datastructure for record
-- types and values. For most purposes, we want to deal with record
-- fields in a canonical order; but for user interaction purposes, we
-- generally want to display the fields in the order they were specified
-- by the user (in source files, at the REPL, etc.).
module Cryptol.Utils.RecordMap
-- | An "order insensitive" datastructure. The fields can be accessed
-- either according to a "canonical" order, or based on a "display"
-- order, which matches the order in which the fields were originally
-- specified.
data RecordMap a b
-- | The order in which the fields originally appeared.
displayOrder :: RecordMap a b -> [a]
-- | Return a list of field/value pairs in canonical order.
canonicalFields :: RecordMap a b -> [(a, b)]
-- | Return a list of field/value pairs in display order.
displayFields :: (Show a, Ord a) => RecordMap a b -> [(a, b)]
-- | Retrieve the elements of the record in canonical order of the field
-- names
recordElements :: RecordMap a b -> [b]
-- | Return the fields in this record as a set.
fieldSet :: Ord a => RecordMap a b -> Set a
-- | Generate a record from a list of field/value pairs. Precondition: each
-- field identifier appears at most once in the given list.
recordFromFields :: (Show a, Ord a) => [(a, b)] -> RecordMap a b
-- | Generate a record from a list of field/value pairs. If any field name
-- is repeated, the first repeated name/value pair is returned. Otherwise
-- the constructed record is returned.
recordFromFieldsErr :: (Show a, Ord a) => [(a, b)] -> Either (a, b) (RecordMap a b)
-- | Generate a record from a list of field/value pairs, and also provide
-- the "display" order for the fields directly. Precondition: each field
-- identifier appears at most once in each list, and a field name appears
-- in the display order iff it appears in the field list.
recordFromFieldsWithDisplay :: (Show a, Ord a) => [a] -> [(a, b)] -> RecordMap a b
-- | Lookup the value of a field
lookupField :: Ord a => a -> RecordMap a b -> Maybe b
-- | Update the value of a field by applying the given function. If the
-- field is not present in the record, return Nothing.
adjustField :: forall a b. Ord a => a -> (b -> b) -> RecordMap a b -> Maybe (RecordMap a b)
-- | Traverse the elements of the given record map in canonical order,
-- applying the given action.
traverseRecordMap :: Applicative t => (a -> b -> t c) -> RecordMap a b -> t (RecordMap a c)
-- | Apply the given function to each element of a record.
mapWithFieldName :: (a -> b -> c) -> RecordMap a b -> RecordMap a c
-- | Zip together the fields of two records using the provided action. If
-- some field is present in one record, but not the other, an Either
-- a a will be returned, indicating which record is missing the
-- field, and returning the name of the missing field.
--
-- The displayOrder of the resulting record will be taken from
-- the first argument (rather arbitrarily).
zipRecordsM :: forall t a b c d. (Ord a, Monad t) => (a -> b -> c -> t d) -> RecordMap a b -> RecordMap a c -> t (Either (Either a a) (RecordMap a d))
-- | Pure version of zipRecordsM
zipRecords :: forall a b c d. Ord a => (a -> b -> c -> d) -> RecordMap a b -> RecordMap a c -> Either (Either a a) (RecordMap a d)
-- | The function recordMapAccum threads an accumulating argument through
-- the map in canonical order of fields.
recordMapAccum :: (a -> b -> (a, c)) -> a -> RecordMap k b -> (a, RecordMap k c)
instance (GHC.Classes.Ord a, GHC.Classes.Eq b) => GHC.Classes.Eq (Cryptol.Utils.RecordMap.RecordMap a b)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (Cryptol.Utils.RecordMap.RecordMap a b)
instance (GHC.Show.Show a, GHC.Classes.Ord a, GHC.Show.Show b) => GHC.Show.Show (Cryptol.Utils.RecordMap.RecordMap a b)
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Cryptol.Utils.RecordMap.RecordMap a b)
instance GHC.Base.Functor (Cryptol.Utils.RecordMap.RecordMap a)
instance Data.Foldable.Foldable (Cryptol.Utils.RecordMap.RecordMap a)
instance Data.Traversable.Traversable (Cryptol.Utils.RecordMap.RecordMap a)
-- | This module contains types related to typechecking and the output of
-- the typechecker. In particular, it should contain the types needed by
-- interface files (see Interface), which are (kind of) the output
-- of the typechker.
module Cryptol.TypeCheck.Type
class FVS t
fvs :: FVS t => t -> Set TVar
-- | The type is "simple" (i.e., it contains no type functions).
type SType = Type
-- | Information about an abstract type.
data AbstractType
AbstractType :: Name -> Kind -> ([TParam], [Prop]) -> Maybe Fixity -> Maybe Text -> AbstractType
[atName] :: AbstractType -> Name
[atKind] :: AbstractType -> Kind
[atCtrs] :: AbstractType -> ([TParam], [Prop])
[atFixitiy] :: AbstractType -> Maybe Fixity
[atDoc] :: AbstractType -> Maybe Text
-- | Named records
data Newtype
Newtype :: Name -> [TParam] -> [Prop] -> RecordMap Ident Type -> Maybe Text -> Newtype
[ntName] :: Newtype -> Name
[ntParams] :: Newtype -> [TParam]
[ntConstraints] :: Newtype -> [Prop]
[ntFields] :: Newtype -> RecordMap Ident Type
[ntDoc] :: Newtype -> Maybe Text
-- | Type synonym.
data TySyn
TySyn :: Name -> [TParam] -> [Prop] -> Type -> !Maybe Text -> TySyn
-- | Name
[tsName] :: TySyn -> Name
-- | Parameters
[tsParams] :: TySyn -> [TParam]
-- | Ensure body is OK
[tsConstraints] :: TySyn -> [Prop]
-- | Definition
[tsDef] :: TySyn -> Type
-- | Documentation
[tsDoc] :: TySyn -> !Maybe Text
-- | The type is supposed to be of kind KProp.
type Prop = Type
-- | A type annotated with information on how it came about.
data TypeWithSource
WithSource :: Type -> TypeSource -> !Maybe Range -> TypeWithSource
[twsType] :: TypeWithSource -> Type
[twsSource] :: TypeWithSource -> TypeSource
[twsRange] :: TypeWithSource -> !Maybe Range
data ArgDescr
ArgDescr :: Maybe Name -> Maybe Int -> ArgDescr
[argDescrFun] :: ArgDescr -> Maybe Name
[argDescrNumber] :: ArgDescr -> Maybe Int
-- | Explains how this type came to be, for better error messages.
data TypeSource
-- | Name of module parameter
TVFromModParam :: Name -> TypeSource
-- | A variable in a signature
TVFromSignature :: Name -> TypeSource
TypeWildCard :: TypeSource
TypeOfRecordField :: Ident -> TypeSource
TypeOfTupleField :: Int -> TypeSource
TypeOfSeqElement :: TypeSource
LenOfSeq :: TypeSource
TypeParamInstNamed :: Name -> Ident -> TypeSource
TypeParamInstPos :: Name -> Int -> TypeSource
DefinitionOf :: Name -> TypeSource
LenOfCompGen :: TypeSource
TypeOfArg :: ArgDescr -> TypeSource
TypeOfRes :: TypeSource
FunApp :: TypeSource
TypeOfIfCondExpr :: TypeSource
TypeFromUserAnnotation :: TypeSource
GeneratorOfListComp :: TypeSource
TypeErrorPlaceHolder :: TypeSource
data TVarInfo
TVarInfo :: !Range -> !TypeSource -> TVarInfo
-- | Source code that gave rise
[tvarSource] :: TVarInfo -> !Range
-- | Description
[tvarDesc] :: TVarInfo -> !TypeSource
-- | Type variables.
data TVar
-- | Unique, kind, ids of bound type variables that are in scope. The last
-- field gives us some info for nicer warnings/errors.
TVFree :: !Int -> Kind -> Set TParam -> TVarInfo -> TVar
TVBound :: {-# UNPACK #-} !TParam -> TVar
-- | The internal representation of types. These are assumed to be kind
-- correct.
data Type
-- | Type constant with args
TCon :: !TCon -> ![Type] -> Type
-- | Type variable (free or bound)
TVar :: TVar -> Type
-- | This is just a type annotation, for a type that was written as a type
-- synonym. It is useful so that we can use it to report nicer errors.
-- Example: TUser T ts t is really just the type t that
-- was written as T ts by the user.
TUser :: !Name -> ![Type] -> !Type -> Type
-- | Record type
TRec :: !RecordMap Ident Type -> Type
-- | A newtype
TNewtype :: !Newtype -> ![Type] -> Type
data TPFlavor
TPModParam :: Name -> TPFlavor
TPUnifyVar :: TPFlavor
TPSchemaParam :: Name -> TPFlavor
TPTySynParam :: Name -> TPFlavor
TPPropSynParam :: Name -> TPFlavor
TPNewtypeParam :: Name -> TPFlavor
TPPrimParam :: Name -> TPFlavor
-- | Type parameters.
data TParam
TParam :: !Int -> Kind -> TPFlavor -> !TVarInfo -> TParam
-- | Parameter identifier
[tpUnique] :: TParam -> !Int
-- | Kind of parameter
[tpKind] :: TParam -> Kind
-- | What sort of type parameter is this
[tpFlav] :: TParam -> TPFlavor
-- | A description for better messages.
[tpInfo] :: TParam -> !TVarInfo
-- | The types of polymorphic values.
data Schema
Forall :: [TParam] -> [Prop] -> Type -> Schema
[sVars] :: Schema -> [TParam]
[sProps] :: Schema -> [Prop]
[sType] :: Schema -> Type
-- | A value parameter of a module.
data ModVParam
ModVParam :: Name -> Schema -> Maybe Text -> Maybe Fixity -> ModVParam
[mvpName] :: ModVParam -> Name
[mvpType] :: ModVParam -> Schema
[mvpDoc] :: ModVParam -> Maybe Text
[mvpFixity] :: ModVParam -> Maybe Fixity
-- | A type parameter of a module.
data ModTParam
ModTParam :: Name -> Kind -> !Int -> Maybe Text -> ModTParam
[mtpName] :: ModTParam -> Name
[mtpKind] :: ModTParam -> Kind
-- | The number of the parameter in the module This is used when we move
-- parameters from the module level to individual declarations (type
-- synonyms in particular)
[mtpNumber] :: ModTParam -> !Int
[mtpDoc] :: ModTParam -> Maybe Text
mtpParam :: ModTParam -> TParam
tMono :: Type -> Schema
isMono :: Schema -> Maybe Type
schemaParam :: Name -> TPFlavor
tySynParam :: Name -> TPFlavor
propSynParam :: Name -> TPFlavor
newtypeParam :: Name -> TPFlavor
modTyParam :: Name -> TPFlavor
tpfName :: TPFlavor -> Maybe Name
tpName :: TParam -> Maybe Name
tvInfo :: TVar -> TVarInfo
tvUnique :: TVar -> Int
noArgDescr :: ArgDescr
-- | Get the names of something that is related to the tvar.
tvSourceName :: TypeSource -> Maybe Name
quickApply :: Kind -> [a] -> Kind
kindResult :: Kind -> Kind
tpVar :: TParam -> TVar
-- | Compute the set of all Props that are implied by the given
-- prop via superclass constraints.
superclassSet :: Prop -> Set Prop
newtypeConType :: Newtype -> Schema
abstractTypeTC :: AbstractType -> TCon
isFreeTV :: TVar -> Bool
isBoundTV :: TVar -> Bool
tIsError :: Type -> Maybe Type
tHasErrors :: Type -> Bool
tIsNat' :: Type -> Maybe Nat'
tIsNum :: Type -> Maybe Integer
tIsInf :: Type -> Bool
tIsVar :: Type -> Maybe TVar
tIsFun :: Type -> Maybe (Type, Type)
tIsSeq :: Type -> Maybe (Type, Type)
tIsBit :: Type -> Bool
tIsInteger :: Type -> Bool
tIsIntMod :: Type -> Maybe Type
tIsRational :: Type -> Bool
tIsFloat :: Type -> Maybe (Type, Type)
tIsTuple :: Type -> Maybe [Type]
tIsRec :: Type -> Maybe (RecordMap Ident Type)
tIsBinFun :: TFun -> Type -> Maybe (Type, Type)
-- | Split up repeated occurances of the given binary type-level function.
tSplitFun :: TFun -> Type -> [Type]
pIsFin :: Prop -> Maybe Type
pIsPrime :: Prop -> Maybe Type
pIsGeq :: Prop -> Maybe (Type, Type)
pIsEqual :: Prop -> Maybe (Type, Type)
pIsZero :: Prop -> Maybe Type
pIsLogic :: Prop -> Maybe Type
pIsRing :: Prop -> Maybe Type
pIsField :: Prop -> Maybe Type
pIsIntegral :: Prop -> Maybe Type
pIsRound :: Prop -> Maybe Type
pIsEq :: Prop -> Maybe Type
pIsCmp :: Prop -> Maybe Type
pIsSignedCmp :: Prop -> Maybe Type
pIsLiteral :: Prop -> Maybe (Type, Type)
pIsLiteralLessThan :: Prop -> Maybe (Type, Type)
pIsFLiteral :: Prop -> Maybe (Type, Type, Type, Type)
pIsTrue :: Prop -> Bool
pIsWidth :: Prop -> Maybe Type
pIsValidFloat :: Prop -> Maybe (Type, Type)
tNum :: Integral a => a -> Type
tZero :: Type
tOne :: Type
tTwo :: Type
tInf :: Type
tNat' :: Nat' -> Type
tAbstract :: UserTC -> [Type] -> Type
tNewtype :: Newtype -> [Type] -> Type
tBit :: Type
tInteger :: Type
tRational :: Type
tFloat :: Type -> Type -> Type
tIntMod :: Type -> Type
tArray :: Type -> Type -> Type
tWord :: Type -> Type
tSeq :: Type -> Type -> Type
tChar :: Type
tString :: Int -> Type
tRec :: RecordMap Ident Type -> Type
tTuple :: [Type] -> Type
-- | Make a function type.
tFun :: Type -> Type -> Type
infixr 5 `tFun`
-- | Eliminate outermost type synonyms.
tNoUser :: Type -> Type
-- | Make an error value of the given type to replace the given malformed
-- type (the argument to the error function)
tError :: Type -> Type
tf1 :: TFun -> Type -> Type
tf2 :: TFun -> Type -> Type -> Type
tf3 :: TFun -> Type -> Type -> Type -> Type
tSub :: Type -> Type -> Type
tMul :: Type -> Type -> Type
tDiv :: Type -> Type -> Type
tMod :: Type -> Type -> Type
tExp :: Type -> Type -> Type
tMin :: Type -> Type -> Type
tCeilDiv :: Type -> Type -> Type
tCeilMod :: Type -> Type -> Type
tLenFromThenTo :: Type -> Type -> Type -> Type
-- | Equality for numeric types.
(=#=) :: Type -> Type -> Prop
infix 4 =#=
(=/=) :: Type -> Type -> Prop
pZero :: Type -> Prop
pLogic :: Type -> Prop
pRing :: Type -> Prop
pIntegral :: Type -> Prop
pField :: Type -> Prop
pRound :: Type -> Prop
pEq :: Type -> Prop
pCmp :: Type -> Prop
pSignedCmp :: Type -> Prop
pLiteral :: Type -> Type -> Prop
pLiteralLessThan :: Type -> Type -> Prop
-- | Make a greater-than-or-equal-to constraint.
(>==) :: Type -> Type -> Prop
infix 4 >==
-- | A Has constraint, used for tuple and record selection.
pHas :: Selector -> Type -> Type -> Prop
pTrue :: Prop
pAnd :: [Prop] -> Prop
pSplitAnd :: Prop -> [Prop]
pFin :: Type -> Prop
pValidFloat :: Type -> Type -> Type
pPrime :: Type -> Prop
noFreeVariables :: FVS t => t -> Bool
freeParams :: FVS t => t -> Set TParam
addTNames :: [TParam] -> NameMap -> NameMap
ppNewtypeShort :: Newtype -> Doc
pickTVarName :: Kind -> TypeSource -> Int -> Doc
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.ModTParam
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.ModTParam
instance GHC.Show.Show Cryptol.TypeCheck.Type.ModTParam
instance GHC.Show.Show Cryptol.TypeCheck.Type.TPFlavor
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.TPFlavor
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.TPFlavor
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.ArgDescr
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.ArgDescr
instance GHC.Show.Show Cryptol.TypeCheck.Type.ArgDescr
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.TypeSource
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.TypeSource
instance GHC.Show.Show Cryptol.TypeCheck.Type.TypeSource
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.TVarInfo
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.TVarInfo
instance GHC.Show.Show Cryptol.TypeCheck.Type.TVarInfo
instance GHC.Show.Show Cryptol.TypeCheck.Type.TParam
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.TParam
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.TParam
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.TVar
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.TVar
instance GHC.Show.Show Cryptol.TypeCheck.Type.TVar
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.Type
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.Type
instance GHC.Show.Show Cryptol.TypeCheck.Type.Type
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.Newtype
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.Newtype
instance GHC.Show.Show Cryptol.TypeCheck.Type.Newtype
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.TySyn
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.TySyn
instance GHC.Show.Show Cryptol.TypeCheck.Type.TySyn
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.Schema
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.Schema
instance GHC.Show.Show Cryptol.TypeCheck.Type.Schema
instance GHC.Classes.Eq Cryptol.TypeCheck.Type.Schema
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.ModVParam
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.ModVParam
instance GHC.Show.Show Cryptol.TypeCheck.Type.ModVParam
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Type.AbstractType
instance GHC.Generics.Generic Cryptol.TypeCheck.Type.AbstractType
instance GHC.Show.Show Cryptol.TypeCheck.Type.AbstractType
instance Cryptol.TypeCheck.Type.FVS Cryptol.TypeCheck.Type.Type
instance Cryptol.TypeCheck.Type.FVS a => Cryptol.TypeCheck.Type.FVS (GHC.Maybe.Maybe a)
instance Cryptol.TypeCheck.Type.FVS a => Cryptol.TypeCheck.Type.FVS [a]
instance (Cryptol.TypeCheck.Type.FVS a, Cryptol.TypeCheck.Type.FVS b) => Cryptol.TypeCheck.Type.FVS (a, b)
instance Cryptol.TypeCheck.Type.FVS Cryptol.TypeCheck.Type.Schema
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Type.Schema
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.Type.Schema)
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.Type.TySyn
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Type.TySyn
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.Type.TySyn)
instance GHC.Classes.Eq Cryptol.TypeCheck.Type.Newtype
instance GHC.Classes.Ord Cryptol.TypeCheck.Type.Newtype
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.Type.Type
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.Type.Newtype
instance GHC.Classes.Eq Cryptol.TypeCheck.Type.Type
instance GHC.Classes.Ord Cryptol.TypeCheck.Type.Type
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Type.Newtype
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.Type.Newtype)
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.Type.Type)
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Type.Type
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.Type.TVar
instance GHC.Classes.Eq Cryptol.TypeCheck.Type.TVar
instance GHC.Classes.Ord Cryptol.TypeCheck.Type.TVar
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.Type.TVar)
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Type.TVar
instance Cryptol.TypeCheck.TCon.HasKind Cryptol.TypeCheck.Type.TParam
instance GHC.Classes.Eq Cryptol.TypeCheck.Type.TParam
instance GHC.Classes.Ord Cryptol.TypeCheck.Type.TParam
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Type.TParam
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.Type.TParam)
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Type.TVarInfo
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Type.TypeSource
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Type.ArgDescr
module Cryptol.TypeCheck.TypePat
aInf :: Pat Type ()
aNat :: Pat Type Integer
aNat' :: Pat Type Nat'
anAdd :: Pat Type (Type, Type)
(|-|) :: Pat Type (Type, Type)
aMul :: Pat Type (Type, Type)
(|^|) :: Pat Type (Type, Type)
(|/|) :: Pat Type (Type, Type)
(|%|) :: Pat Type (Type, Type)
aMin :: Pat Type (Type, Type)
aMax :: Pat Type (Type, Type)
aWidth :: Pat Type Type
aCeilDiv :: Pat Type (Type, Type)
aCeilMod :: Pat Type (Type, Type)
aLenFromThenTo :: Pat Type (Type, Type, Type)
aLiteral :: Pat Prop (Type, Type)
aLiteralLessThan :: Pat Prop (Type, Type)
aLogic :: Pat Prop Type
aTVar :: Pat Type TVar
aFreeTVar :: Pat Type TVar
aBit :: Pat Type ()
aSeq :: Pat Type (Type, Type)
aWord :: Pat Type Type
aChar :: Pat Type ()
aTuple :: Pat Type [Type]
aRec :: Pat Type (RecordMap Ident Type)
(|->|) :: Pat Type (Type, Type)
aFin :: Pat Prop Type
(|=|) :: Pat Prop (Type, Type)
(|/=|) :: Pat Prop (Type, Type)
(|>=|) :: Pat Prop (Type, Type)
aAnd :: Pat Prop (Prop, Prop)
aTrue :: Pat Prop ()
anError :: Kind -> Pat Type ()
module Cryptol.TypeCheck.SimpType
tRebuild' :: Bool -> Type -> Type
tRebuild :: Type -> Type
tCon :: TCon -> [Type] -> Type
tAdd :: Type -> Type -> Type
tSub :: Type -> Type -> Type
tMul :: Type -> Type -> Type
tDiv :: Type -> Type -> Type
tMod :: Type -> Type -> Type
tCeilDiv :: Type -> Type -> Type
tCeilMod :: Type -> Type -> Type
tExp :: Type -> Type -> Type
tMin :: Type -> Type -> Type
tMax :: Type -> Type -> Type
tWidth :: Type -> Type
tLenFromThenTo :: Type -> Type -> Type -> Type
total :: ([Nat'] -> Nat') -> [Nat'] -> Maybe Nat'
op1 :: (a -> b) -> [a] -> b
op2 :: (a -> a -> b) -> [a] -> b
op3 :: (a -> a -> a -> b) -> [a] -> b
-- | Common checks: check for error, or simple full evaluation. We assume
-- that input kinds and the result kind are the same (i.e., Nat)
tOp :: TFun -> ([Nat'] -> Maybe Nat') -> [Type] -> Maybe Type
module Cryptol.Parser.AST
-- | Identifiers, along with a flag that indicates whether or not they're
-- infix operators. The boolean is present just as cached information
-- from the lexer, and never used during comparisons.
data Ident
mkIdent :: Text -> Ident
mkInfix :: Text -> Ident
isInfixIdent :: Ident -> Bool
nullIdent :: Ident -> Bool
identText :: Ident -> Text
-- | Top-level Module names are just text.
data ModName
modRange :: Module name -> Range
-- | Names that originate in the parser.
data PName
-- | Unqualified names like x, Foo, or +.
UnQual :: !Ident -> PName
-- | Qualified names like Foo::bar or module::!.
Qual :: !ModName -> !Ident -> PName
-- | Fresh names generated by a pass.
NewName :: !Pass -> !Int -> PName
getModName :: PName -> Maybe ModName
getIdent :: PName -> Ident
mkUnqual :: Ident -> PName
mkQual :: ModName -> Ident -> PName
data Named a
Named :: Located Ident -> a -> Named a
[name] :: Named a -> Located Ident
[value] :: Named a -> a
-- | Passes that can generate fresh names.
data Pass
NoPat :: Pass
MonoValues :: Pass
-- | Information about associativity.
data Assoc
LeftAssoc :: Assoc
RightAssoc :: Assoc
NonAssoc :: Assoc
data Schema n
Forall :: [TParam n] -> [Prop n] -> Type n -> Maybe Range -> Schema n
data TParam n
TParam :: n -> Maybe Kind -> Maybe Range -> TParam n
[tpName] :: TParam n -> n
[tpKind] :: TParam n -> Maybe Kind
[tpRange] :: TParam n -> Maybe Range
data Kind
KProp :: Kind
KNum :: Kind
KType :: Kind
KFun :: Kind -> Kind -> Kind
data Type n
-- |
-- [8] -> [8]
--
TFun :: Type n -> Type n -> Type n
-- |
-- [8] a
--
TSeq :: Type n -> Type n -> Type n
-- |
-- Bit
--
TBit :: Type n
-- |
-- 10
--
TNum :: Integer -> Type n
-- |
-- a
--
TChar :: Char -> Type n
-- | A type variable or synonym
TUser :: n -> [Type n] -> Type n
-- |
-- `{ x = [8], y = Integer }
--
TTyApp :: [Named (Type n)] -> Type n
-- |
-- { x : [8], y : [32] }
--
TRecord :: Rec (Type n) -> Type n
-- |
-- ([8], [32])
--
TTuple :: [Type n] -> Type n
-- | _, just some type.
TWild :: Type n
-- | Location information
TLocated :: Type n -> Range -> Type n
-- |
-- (ty)
--
TParens :: Type n -> Type n
-- |
-- ty + ty
--
TInfix :: Type n -> Located n -> Fixity -> Type n -> Type n
-- | A Prop is a Type that represents a type constraint.
newtype Prop n
CType :: Type n -> Prop n
tsName :: TySyn name -> Located name
psName :: PropSyn name -> Located name
tsFixity :: TySyn name -> Maybe Fixity
psFixity :: PropSyn name -> Maybe Fixity
type Module = ModuleG ModName
-- | A parsed module.
data ModuleG mname name
Module :: Located mname -> !Maybe (Located ModName) -> [TopDecl name] -> ModuleG mname name
-- | Name of the module
[mName] :: ModuleG mname name -> Located mname
-- | Functor to instantiate (if this is a functor instnaces) , mImports ::
-- [Located Import] -- ^ Imports for the module
[mInstance] :: ModuleG mname name -> !Maybe (Located ModName)
-- | Declartions for the module
[mDecls] :: ModuleG mname name -> [TopDecl name]
mImports :: ModuleG mname name -> [Located Import]
mSubmoduleImports :: ModuleG mname name -> [Located (ImportG name)]
newtype Program name
Program :: [TopDecl name] -> Program name
data TopDecl name
Decl :: TopLevel (Decl name) -> TopDecl name
DPrimType :: TopLevel (PrimType name) -> TopDecl name
-- | @newtype T as = t
TDNewtype :: TopLevel (Newtype name) -> TopDecl name
-- |
-- include File
--
Include :: Located FilePath -> TopDecl name
-- |
-- parameter type T : #
--
DParameterType :: ParameterType name -> TopDecl name
-- |
-- parameter type constraint (fin T)
--
DParameterConstraint :: [Located (Prop name)] -> TopDecl name
-- |
-- parameter someVal : [256]
--
DParameterFun :: ParameterFun name -> TopDecl name
-- | Nested module
DModule :: TopLevel (NestedModule name) -> TopDecl name
-- | An import declaration
DImport :: Located (ImportG (ImpName name)) -> TopDecl name
data Decl name
DSignature :: [Located name] -> Schema name -> Decl name
DFixity :: !Fixity -> [Located name] -> Decl name
DPragma :: [Located name] -> Pragma -> Decl name
DBind :: Bind name -> Decl name
-- | A group of recursive bindings, introduced by the renamer.
DRec :: [Bind name] -> Decl name
DPatBind :: Pattern name -> Expr name -> Decl name
DType :: TySyn name -> Decl name
DProp :: PropSyn name -> Decl name
DLocated :: Decl name -> Range -> Decl name
data Fixity
Fixity :: !Assoc -> !Int -> Fixity
[fAssoc] :: Fixity -> !Assoc
[fLevel] :: Fixity -> !Int
-- | The fixity used when none is provided.
defaultFixity :: Fixity
data FixityCmp
FCError :: FixityCmp
FCLeft :: FixityCmp
FCRight :: FixityCmp
-- | Let op1 have fixity f1 and op2 have fixity
-- f2. Then compareFixity f1 f2 determines how to parse the
-- infix expression x op1 y op2 z@.
--
--
-- - FCLeft: (x op1 y) op2 z
-- - FCRight: x op1 (y op2 z)
-- - FCError: no parse
--
compareFixity :: Fixity -> Fixity -> FixityCmp
data TySyn n
TySyn :: Located n -> Maybe Fixity -> [TParam n] -> Type n -> TySyn n
data PropSyn n
PropSyn :: Located n -> Maybe Fixity -> [TParam n] -> [Prop n] -> PropSyn n
-- | Bindings. Notes:
--
--
-- - The parser does not associate type signatures and pragmas with
-- their bindings: this is done in a separate pass, after de-sugaring
-- pattern bindings. In this way we can associate pragmas and type
-- signatures with the variables defined by pattern bindings as
-- well.
-- - Currently, there is no surface syntax for defining monomorphic
-- bindings (i.e., bindings that will not be automatically generalized by
-- the type checker. However, they are useful when de-sugaring
-- patterns.
--
data Bind name
Bind :: Located name -> [Pattern name] -> Located (BindDef name) -> Maybe (Schema name) -> Bool -> Maybe Fixity -> [Pragma] -> Bool -> Maybe Text -> !ExportType -> Bind name
-- | Defined thing
[bName] :: Bind name -> Located name
-- | Parameters
[bParams] :: Bind name -> [Pattern name]
-- | Definition
[bDef] :: Bind name -> Located (BindDef name)
-- | Optional type sig
[bSignature] :: Bind name -> Maybe (Schema name)
-- | Infix operator?
[bInfix] :: Bind name -> Bool
-- | Optional fixity info
[bFixity] :: Bind name -> Maybe Fixity
-- | Optional pragmas
[bPragmas] :: Bind name -> [Pragma]
-- | Is this a monomorphic binding
[bMono] :: Bind name -> Bool
-- | Optional doc string
[bDoc] :: Bind name -> Maybe Text
[bExport] :: Bind name -> !ExportType
data BindDef name
DPrim :: BindDef name
DExpr :: Expr name -> BindDef name
type LBindDef = Located (BindDef PName)
data Pragma
PragmaNote :: String -> Pragma
PragmaProperty :: Pragma
-- | Export information for a declaration.
data ExportType
Public :: ExportType
Private :: ExportType
-- | A top-level module declaration.
data TopLevel a
TopLevel :: ExportType -> Maybe (Located Text) -> a -> TopLevel a
[tlExport] :: TopLevel a -> ExportType
[tlDoc] :: TopLevel a -> Maybe (Located Text)
[tlValue] :: TopLevel a -> a
type Import = ImportG ModName
-- | An import declaration.
data ImportG mname
Import :: !mname -> Maybe ModName -> Maybe ImportSpec -> ImportG mname
[iModule] :: ImportG mname -> !mname
[iAs] :: ImportG mname -> Maybe ModName
[iSpec] :: ImportG mname -> Maybe ImportSpec
-- | The list of names following an import.
data ImportSpec
Hiding :: [Ident] -> ImportSpec
Only :: [Ident] -> ImportSpec
data ImpName name
ImpTop :: ModName -> ImpName name
ImpNested :: name -> ImpName name
data Newtype name
Newtype :: Located name -> [TParam name] -> Rec (Type name) -> Newtype name
-- | Type name
[nName] :: Newtype name -> Located name
-- | Type params
[nParams] :: Newtype name -> [TParam name]
-- | Body
[nBody] :: Newtype name -> Rec (Type name)
-- | A declaration for a type with no implementation.
data PrimType name
PrimType :: Located name -> Located Kind -> ([TParam name], [Prop name]) -> Maybe Fixity -> PrimType name
[primTName] :: PrimType name -> Located name
[primTKind] :: PrimType name -> Located Kind
-- | parameters are in the order used by the type constructor.
[primTCts] :: PrimType name -> ([TParam name], [Prop name])
[primTFixity] :: PrimType name -> Maybe Fixity
-- | A type parameter
data ParameterType name
ParameterType :: Located name -> Kind -> Maybe Text -> Maybe Fixity -> !Int -> ParameterType name
-- | name of type parameter
[ptName] :: ParameterType name -> Located name
-- | kind of parameter
[ptKind] :: ParameterType name -> Kind
-- | optional documentation
[ptDoc] :: ParameterType name -> Maybe Text
-- | info for infix use
[ptFixity] :: ParameterType name -> Maybe Fixity
-- | number of the parameter
[ptNumber] :: ParameterType name -> !Int
-- | A value parameter
data ParameterFun name
ParameterFun :: Located name -> Schema name -> Maybe Text -> Maybe Fixity -> ParameterFun name
-- | name of value parameter
[pfName] :: ParameterFun name -> Located name
-- | schema for parameter
[pfSchema] :: ParameterFun name -> Schema name
-- | optional documentation
[pfDoc] :: ParameterFun name -> Maybe Text
-- | info for infix use
[pfFixity] :: ParameterFun name -> Maybe Fixity
newtype NestedModule name
NestedModule :: ModuleG name name -> NestedModule name
-- | Input at the REPL, which can be an expression, a let
-- statement, or empty (possibly a comment).
data ReplInput name
ExprInput :: Expr name -> ReplInput name
LetInput :: [Decl name] -> ReplInput name
EmptyInput :: ReplInput name
data Expr n
-- |
-- x
--
EVar :: n -> Expr n
-- |
-- 0x10
--
ELit :: Literal -> Expr n
-- |
-- -1
--
ENeg :: Expr n -> Expr n
-- |
-- ~1
--
EComplement :: Expr n -> Expr n
-- |
-- generate f
--
EGenerate :: Expr n -> Expr n
-- |
-- (1,2,3)
--
ETuple :: [Expr n] -> Expr n
-- |
-- { x = 1, y = 2 }
--
ERecord :: Rec (Expr n) -> Expr n
-- |
-- e.l
--
ESel :: Expr n -> Selector -> Expr n
-- |
-- { r | x = e }
--
EUpd :: Maybe (Expr n) -> [UpdField n] -> Expr n
-- |
-- [1,2,3]
--
EList :: [Expr n] -> Expr n
-- |
-- [1, 5 .. 117 : t]
--
EFromTo :: Type n -> Maybe (Type n) -> Type n -> Maybe (Type n) -> Expr n
-- |
-- [1 .. 10 by 2 : t ]
--
EFromToBy :: Bool -> Type n -> Type n -> Type n -> Maybe (Type n) -> Expr n
-- |
-- [10 .. 1 down by 2 : t ]
--
EFromToDownBy :: Bool -> Type n -> Type n -> Type n -> Maybe (Type n) -> Expr n
-- |
-- [ 1 .. < 10 : t ]
--
EFromToLessThan :: Type n -> Type n -> Maybe (Type n) -> Expr n
-- |
-- [1, 3 ...]
--
EInfFrom :: Expr n -> Maybe (Expr n) -> Expr n
-- |
-- [ 1 | x <- xs ]
--
EComp :: Expr n -> [[Match n]] -> Expr n
-- |
-- f x
--
EApp :: Expr n -> Expr n -> Expr n
-- |
-- f `{x = 8}, f`{8}
--
EAppT :: Expr n -> [TypeInst n] -> Expr n
-- |
-- if ok then e1 else e2
--
EIf :: Expr n -> Expr n -> Expr n -> Expr n
-- |
-- 1 + x where { x = 2 }
--
EWhere :: Expr n -> [Decl n] -> Expr n
-- |
-- 1 : [8]
--
ETyped :: Expr n -> Type n -> Expr n
-- | `(x + 1), x is a type
ETypeVal :: Type n -> Expr n
-- |
-- \x y -> x
--
EFun :: FunDesc n -> [Pattern n] -> Expr n -> Expr n
-- | position annotation
ELocated :: Expr n -> Range -> Expr n
-- | splitAt x (Introduced by NoPat)
ESplit :: Expr n -> Expr n
-- | (e) (Removed by Fixity)
EParens :: Expr n -> Expr n
-- | a + b (Removed by Fixity)
EInfix :: Expr n -> Located n -> Fixity -> Expr n -> Expr n
-- | Literals.
data Literal
-- | 0x10 (HexLit 2)
ECNum :: Integer -> NumInfo -> Literal
-- |
-- a
--
ECChar :: Char -> Literal
-- |
-- 1.2e3
--
ECFrac :: Rational -> FracInfo -> Literal
-- |
-- "hello"
--
ECString :: String -> Literal
-- | Infromation about the representation of a numeric constant.
data NumInfo
-- | n-digit binary literal
BinLit :: Text -> Int -> NumInfo
-- | n-digit octal literal
OctLit :: Text -> Int -> NumInfo
-- | overloaded decimal literal
DecLit :: Text -> NumInfo
-- | n-digit hex literal
HexLit :: Text -> Int -> NumInfo
-- | polynomial literal
PolyLit :: Int -> NumInfo
-- | Information about fractional literals.
data FracInfo
BinFrac :: Text -> FracInfo
OctFrac :: Text -> FracInfo
DecFrac :: Text -> FracInfo
HexFrac :: Text -> FracInfo
data Match name
-- | p <- e
Match :: Pattern name -> Expr name -> Match name
MatchLet :: Bind name -> Match name
data Pattern n
-- |
-- x
--
PVar :: Located n -> Pattern n
-- |
-- _
--
PWild :: Pattern n
-- |
-- (x,y,z)
--
PTuple :: [Pattern n] -> Pattern n
-- |
-- { x = (a,b,c), y = z }
--
PRecord :: Rec (Pattern n) -> Pattern n
-- |
-- [ x, y, z ]
--
PList :: [Pattern n] -> Pattern n
-- |
-- x : [8]
--
PTyped :: Pattern n -> Type n -> Pattern n
-- |
-- (x # y)
--
PSplit :: Pattern n -> Pattern n -> Pattern n
-- | Location information
PLocated :: Pattern n -> Range -> Pattern n
-- | Selectors are used for projecting from various components. Each
-- selector has an option spec to specify the shape of the thing that is
-- being selected. Currently, there is no surface syntax for list
-- selectors, but they are used during the desugaring of patterns.
data Selector
-- | Zero-based tuple selection. Optionally specifies the shape of the
-- tuple (one-based).
TupleSel :: Int -> Maybe Int -> Selector
-- | Record selection. Optionally specifies the shape of the record.
RecordSel :: Ident -> Maybe [Ident] -> Selector
-- | List selection. Optionally specifies the length of the list.
ListSel :: Int -> Maybe Int -> Selector
data TypeInst name
NamedInst :: Named (Type name) -> TypeInst name
PosInst :: Type name -> TypeInst name
data UpdField n
-- | non-empty list x.y = e
UpdField :: UpdHow -> [Located Selector] -> Expr n -> UpdField n
data UpdHow
UpdSet :: UpdHow
-- | Are we setting or updating a field.
UpdFun :: UpdHow
-- | Description of functions. Only trivial information is provided here by
-- the parser. The NoPat pass fills this in as required.
data FunDesc n
FunDesc :: Maybe n -> Int -> FunDesc n
-- | Name of this function, if it has one
[funDescrName] :: FunDesc n -> Maybe n
-- | number of previous arguments to this function bound in surrounding
-- lambdas (defaults to 0)
[funDescrArgOffset] :: FunDesc n -> Int
emptyFunDesc :: FunDesc n
data Located a
Located :: !Range -> !a -> Located a
[srcRange] :: Located a -> !Range
[thing] :: Located a -> !a
-- | A name with location information.
type LPName = Located PName
-- | A string with location information.
type LString = Located String
-- | An identifier with location information.
type LIdent = Located Ident
class NoPos t
noPos :: NoPos t => t -> t
-- | Conversational printing of kinds (e.g., to use in error
-- messages)
cppKind :: Kind -> Doc
-- | Display the thing selected by the selector, nicely.
ppSelector :: Selector -> Doc
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.ImpName name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.ImpName name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.ImpName name)
instance Control.DeepSeq.NFData Cryptol.Parser.AST.ImportSpec
instance GHC.Generics.Generic Cryptol.Parser.AST.ImportSpec
instance GHC.Show.Show Cryptol.Parser.AST.ImportSpec
instance GHC.Classes.Eq Cryptol.Parser.AST.ImportSpec
instance Control.DeepSeq.NFData mname => Control.DeepSeq.NFData (Cryptol.Parser.AST.ImportG mname)
instance GHC.Generics.Generic (Cryptol.Parser.AST.ImportG mname)
instance GHC.Show.Show mname => GHC.Show.Show (Cryptol.Parser.AST.ImportG mname)
instance GHC.Classes.Eq mname => GHC.Classes.Eq (Cryptol.Parser.AST.ImportG mname)
instance Control.DeepSeq.NFData Cryptol.Parser.AST.Pragma
instance GHC.Generics.Generic Cryptol.Parser.AST.Pragma
instance GHC.Show.Show Cryptol.Parser.AST.Pragma
instance GHC.Classes.Eq Cryptol.Parser.AST.Pragma
instance Control.DeepSeq.NFData Cryptol.Parser.AST.ExportType
instance GHC.Generics.Generic Cryptol.Parser.AST.ExportType
instance GHC.Classes.Ord Cryptol.Parser.AST.ExportType
instance GHC.Show.Show Cryptol.Parser.AST.ExportType
instance GHC.Classes.Eq Cryptol.Parser.AST.ExportType
instance Data.Traversable.Traversable Cryptol.Parser.AST.TopLevel
instance Data.Foldable.Foldable Cryptol.Parser.AST.TopLevel
instance GHC.Base.Functor Cryptol.Parser.AST.TopLevel
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Cryptol.Parser.AST.TopLevel a)
instance GHC.Generics.Generic (Cryptol.Parser.AST.TopLevel a)
instance GHC.Show.Show a => GHC.Show.Show (Cryptol.Parser.AST.TopLevel a)
instance Control.DeepSeq.NFData Cryptol.Parser.AST.NumInfo
instance GHC.Generics.Generic Cryptol.Parser.AST.NumInfo
instance GHC.Show.Show Cryptol.Parser.AST.NumInfo
instance GHC.Classes.Eq Cryptol.Parser.AST.NumInfo
instance Control.DeepSeq.NFData Cryptol.Parser.AST.FracInfo
instance GHC.Generics.Generic Cryptol.Parser.AST.FracInfo
instance GHC.Show.Show Cryptol.Parser.AST.FracInfo
instance GHC.Classes.Eq Cryptol.Parser.AST.FracInfo
instance Control.DeepSeq.NFData Cryptol.Parser.AST.Literal
instance GHC.Generics.Generic Cryptol.Parser.AST.Literal
instance GHC.Show.Show Cryptol.Parser.AST.Literal
instance GHC.Classes.Eq Cryptol.Parser.AST.Literal
instance GHC.Base.Functor Cryptol.Parser.AST.FunDesc
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.FunDesc n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.FunDesc n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.FunDesc n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.FunDesc n)
instance Control.DeepSeq.NFData Cryptol.Parser.AST.UpdHow
instance GHC.Generics.Generic Cryptol.Parser.AST.UpdHow
instance GHC.Show.Show Cryptol.Parser.AST.UpdHow
instance GHC.Classes.Eq Cryptol.Parser.AST.UpdHow
instance GHC.Base.Functor Cryptol.Parser.AST.Named
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Cryptol.Parser.AST.Named a)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Named a)
instance Data.Traversable.Traversable Cryptol.Parser.AST.Named
instance Data.Foldable.Foldable Cryptol.Parser.AST.Named
instance GHC.Show.Show a => GHC.Show.Show (Cryptol.Parser.AST.Named a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Cryptol.Parser.AST.Named a)
instance Control.DeepSeq.NFData Cryptol.Parser.AST.Kind
instance GHC.Generics.Generic Cryptol.Parser.AST.Kind
instance GHC.Show.Show Cryptol.Parser.AST.Kind
instance GHC.Classes.Eq Cryptol.Parser.AST.Kind
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.ParameterType name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.ParameterType name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.ParameterType name)
instance GHC.Classes.Eq name => GHC.Classes.Eq (Cryptol.Parser.AST.ParameterType name)
instance GHC.Base.Functor Cryptol.Parser.AST.TParam
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.TParam n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.TParam n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.TParam n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.TParam n)
instance GHC.Base.Functor Cryptol.Parser.AST.Type
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.Type n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Type n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.Type n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.Type n)
instance GHC.Base.Functor Cryptol.Parser.AST.Pattern
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.Pattern n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Pattern n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.Pattern n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.Pattern n)
instance GHC.Base.Functor Cryptol.Parser.AST.TypeInst
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.TypeInst name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.TypeInst name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.TypeInst name)
instance GHC.Classes.Eq name => GHC.Classes.Eq (Cryptol.Parser.AST.TypeInst name)
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.Newtype name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Newtype name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.Newtype name)
instance GHC.Classes.Eq name => GHC.Classes.Eq (Cryptol.Parser.AST.Newtype name)
instance GHC.Base.Functor Cryptol.Parser.AST.TySyn
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.TySyn n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.TySyn n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.TySyn n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.TySyn n)
instance GHC.Base.Functor Cryptol.Parser.AST.Prop
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.Prop n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Prop n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.Prop n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.Prop n)
instance GHC.Base.Functor Cryptol.Parser.AST.Schema
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.Schema n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Schema n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.Schema n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.Schema n)
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.ParameterFun name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.ParameterFun name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.ParameterFun name)
instance GHC.Classes.Eq name => GHC.Classes.Eq (Cryptol.Parser.AST.ParameterFun name)
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.PrimType name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.PrimType name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.PrimType name)
instance GHC.Base.Functor Cryptol.Parser.AST.PropSyn
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.PropSyn n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.PropSyn n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.PropSyn n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.PropSyn n)
instance GHC.Base.Functor Cryptol.Parser.AST.UpdField
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.UpdField n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.UpdField n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.UpdField n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.UpdField n)
instance GHC.Base.Functor Cryptol.Parser.AST.BindDef
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.BindDef name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.BindDef name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.BindDef name)
instance GHC.Classes.Eq name => GHC.Classes.Eq (Cryptol.Parser.AST.BindDef name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.Bind name)
instance GHC.Base.Functor Cryptol.Parser.AST.Bind
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.Bind name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Bind name)
instance GHC.Classes.Eq name => GHC.Classes.Eq (Cryptol.Parser.AST.Bind name)
instance GHC.Base.Functor Cryptol.Parser.AST.Match
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.Match name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Match name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.Match name)
instance GHC.Classes.Eq name => GHC.Classes.Eq (Cryptol.Parser.AST.Match name)
instance GHC.Base.Functor Cryptol.Parser.AST.Expr
instance Control.DeepSeq.NFData n => Control.DeepSeq.NFData (Cryptol.Parser.AST.Expr n)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Expr n)
instance GHC.Show.Show n => GHC.Show.Show (Cryptol.Parser.AST.Expr n)
instance GHC.Classes.Eq n => GHC.Classes.Eq (Cryptol.Parser.AST.Expr n)
instance GHC.Base.Functor Cryptol.Parser.AST.Decl
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.Decl name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.Decl name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.Decl name)
instance GHC.Classes.Eq name => GHC.Classes.Eq (Cryptol.Parser.AST.Decl name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.ReplInput name)
instance GHC.Classes.Eq name => GHC.Classes.Eq (Cryptol.Parser.AST.ReplInput name)
instance (Control.DeepSeq.NFData mname, Control.DeepSeq.NFData name) => Control.DeepSeq.NFData (Cryptol.Parser.AST.ModuleG mname name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.ModuleG mname name)
instance (GHC.Show.Show mname, GHC.Show.Show name) => GHC.Show.Show (Cryptol.Parser.AST.ModuleG mname name)
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.NestedModule name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.NestedModule name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.NestedModule name)
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.Parser.AST.TopDecl name)
instance GHC.Generics.Generic (Cryptol.Parser.AST.TopDecl name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.TopDecl name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.Parser.AST.Program name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.Position.Located t)
instance Cryptol.Parser.AST.NoPos t => Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Named t)
instance Cryptol.Parser.AST.NoPos Cryptol.Parser.Position.Range
instance Cryptol.Parser.AST.NoPos t => Cryptol.Parser.AST.NoPos [t]
instance Cryptol.Parser.AST.NoPos t => Cryptol.Parser.AST.NoPos (GHC.Maybe.Maybe t)
instance (Cryptol.Parser.AST.NoPos a, Cryptol.Parser.AST.NoPos b) => Cryptol.Parser.AST.NoPos (a, b)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Program name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.ModuleG mname name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.NestedModule name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.TopDecl name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.PrimType name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.ParameterType name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.ParameterFun x)
instance Cryptol.Parser.AST.NoPos a => Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.TopLevel a)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Decl name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Newtype name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Bind name)
instance Cryptol.Parser.AST.NoPos Cryptol.Parser.AST.Pragma
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.TySyn name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.PropSyn name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Expr name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.UpdField name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.TypeInst name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Match name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Pattern name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Schema name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.TParam name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Type name)
instance Cryptol.Parser.AST.NoPos (Cryptol.Parser.AST.Prop name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Program name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.TopDecl name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.ModuleG mname name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.NestedModule name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName mname, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.ModuleG mname name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.NestedModule name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.TopDecl name)
instance Cryptol.Parser.Position.AddLoc (Cryptol.Parser.AST.Expr n)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.Expr name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.Bind name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.Match name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.Decl name)
instance Cryptol.Parser.Position.AddLoc (Cryptol.Parser.AST.Decl name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Decl name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Bind name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.BindDef name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Expr name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.UpdField name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Match name)
instance Cryptol.Utils.PP.PPName name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.PropSyn name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.PrimType name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.PrimType name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.ParameterFun name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.ParameterFun name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.Schema name)
instance Cryptol.Parser.Position.AddLoc (Cryptol.Parser.AST.Schema name)
instance Cryptol.Utils.PP.PPName name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Schema name)
instance Cryptol.Utils.PP.PPName name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Prop name)
instance Cryptol.Utils.PP.PPName name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.TySyn name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.Newtype name)
instance Cryptol.Utils.PP.PPName name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Newtype name)
instance Cryptol.Utils.PP.PPName name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.TypeInst name)
instance Cryptol.Parser.Position.AddLoc (Cryptol.Parser.AST.Pattern name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.Pattern name)
instance Cryptol.Utils.PP.PPName name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Pattern name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.Type name)
instance Cryptol.Parser.Position.AddLoc (Cryptol.Parser.AST.Type name)
instance Cryptol.Utils.PP.PPName name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.Type name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.TParam name)
instance Cryptol.Parser.Position.AddLoc (Cryptol.Parser.AST.TParam name)
instance Cryptol.Utils.PP.PPName name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.TParam name)
instance Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.ParameterType name)
instance (GHC.Show.Show name, Cryptol.Utils.PP.PPName name) => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.ParameterType name)
instance Cryptol.Utils.PP.PP Cryptol.Parser.AST.Kind
instance Cryptol.Parser.Position.HasLoc a => Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.Named a)
instance Cryptol.Utils.PP.PP Cryptol.Parser.AST.UpdHow
instance Cryptol.Utils.PP.PP Cryptol.Parser.AST.Literal
instance Cryptol.Parser.Position.HasLoc a => Cryptol.Parser.Position.HasLoc (Cryptol.Parser.AST.TopLevel a)
instance Cryptol.Utils.PP.PP a => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.TopLevel a)
instance Cryptol.Utils.PP.PP Cryptol.Parser.AST.Pragma
instance Cryptol.Utils.PP.PP mname => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.ImportG mname)
instance Cryptol.Utils.PP.PP Cryptol.Parser.AST.ImportSpec
instance Cryptol.Utils.PP.PP name => Cryptol.Utils.PP.PP (Cryptol.Parser.AST.ImpName name)
-- | Utility functions that are also useful for translating programs from
-- previous Cryptol versions.
module Cryptol.Parser.Utils
translateExprToNumT :: Expr PName -> Maybe (Type PName)
widthIdent :: Ident
-- | This module defines the scoping rules for value- and type-level names
-- in Cryptol.
module Cryptol.Parser.Names
-- | The names defined by a newtype.
tnamesNT :: Newtype name -> ([Located name], ())
-- | Compute the type synonyms/type variables used by a type.
tnamesT :: Ord name => Type name -> Set name
-- | The type names used by a prop.
tnamesC :: Ord name => Prop name -> Set name
-- | The names defined and used by a single declarations.
namesD :: Ord name => Decl name -> ([Located name], Set name)
-- | The type names defined and used by a single declaration.
tnamesD :: Ord name => Decl name -> ([Located name], Set name)
-- | The names defined and used by a single binding.
namesB :: Ord name => Bind name -> ([Located name], Set name)
-- | The names defined by a pattern. These will always be unqualified
-- names.
namesP :: Pattern name -> [Located name]
-- | Remove some defined variables from a set of free variables.
boundNames :: Ord name => [name] -> Set name -> Set name
-- | Remove some defined variables from a set of free variables.
boundNamesSet :: Ord name => Set name -> Set name -> Set name
-- | The purpose of this module is to convert all patterns to variable
-- patterns. It also eliminates pattern bindings by de-sugaring them into
-- Bind. Furthermore, here we associate signatures and pragmas
-- with the names to which they belong.
module Cryptol.Parser.NoPat
class RemovePatterns t
-- | Eliminate all patterns in a program.
removePatterns :: RemovePatterns t => t -> (t, [Error])
data Error
MultipleSignatures :: PName -> [Located (Schema PName)] -> Error
SignatureNoBind :: Located PName -> Schema PName -> Error
PragmaNoBind :: Located PName -> Pragma -> Error
MultipleFixities :: PName -> [Range] -> Error
FixityNoBind :: Located PName -> Error
MultipleDocs :: PName -> [Range] -> Error
instance Control.DeepSeq.NFData Cryptol.Parser.NoPat.Error
instance GHC.Generics.Generic Cryptol.Parser.NoPat.Error
instance GHC.Show.Show Cryptol.Parser.NoPat.Error
instance Cryptol.Parser.NoPat.RemovePatterns (Cryptol.Parser.AST.Program Cryptol.Parser.Name.PName)
instance Cryptol.Parser.NoPat.RemovePatterns (Cryptol.Parser.AST.Expr Cryptol.Parser.Name.PName)
instance Cryptol.Parser.NoPat.RemovePatterns (Cryptol.Parser.AST.ModuleG mname Cryptol.Parser.Name.PName)
instance Cryptol.Parser.NoPat.RemovePatterns [Cryptol.Parser.AST.Decl Cryptol.Parser.Name.PName]
instance Cryptol.Parser.NoPat.RemovePatterns (Cryptol.Parser.AST.NestedModule Cryptol.Parser.Name.PName)
instance GHC.Base.Functor Cryptol.Parser.NoPat.NoPatM
instance GHC.Base.Applicative Cryptol.Parser.NoPat.NoPatM
instance GHC.Base.Monad Cryptol.Parser.NoPat.NoPatM
instance Cryptol.Utils.PP.PP Cryptol.Parser.NoPat.Error
module Cryptol.ModuleSystem.Renamer.Error
data RenamerError
-- | Multiple imported symbols contain this name
MultipleSyms :: Located PName -> [Name] -> RenamerError
-- | Some name not bound to any definition
UnboundName :: Namespace -> Located PName -> RenamerError
-- | An environment has produced multiple overlapping symbols
OverlappingSyms :: [Name] -> RenamerError
-- | expected, actual. When a name is missing from the expected namespace,
-- but exists in another
WrongNamespace :: Namespace -> Namespace -> Located PName -> RenamerError
-- | When the fixity of two operators conflict
FixityError :: Located Name -> Fixity -> Located Name -> Fixity -> RenamerError
-- | When it's not possible to produce a Prop from a Type.
InvalidConstraint :: Type PName -> RenamerError
-- | When a builtin type/type-function is used incorrectly.
MalformedBuiltin :: Type PName -> PName -> RenamerError
-- | When a builtin type is named in a binder.
BoundReservedType :: PName -> Maybe Range -> Doc -> RenamerError
-- | When record updates overlap (e.g., { r | x = e1, x.y = e2 })
OverlappingRecordUpdate :: Located [Selector] -> Located [Selector] -> RenamerError
InvalidDependency :: [DepName] -> RenamerError
data DepName
NamedThing :: Name -> DepName
-- | identifed by location in source
ConstratintAt :: Range -> DepName
depNameLoc :: DepName -> Range
data RenamerWarning
SymbolShadowed :: PName -> Name -> [Name] -> RenamerWarning
UnusedName :: Name -> RenamerWarning
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Renamer.Error.DepName
instance GHC.Generics.Generic Cryptol.ModuleSystem.Renamer.Error.DepName
instance GHC.Show.Show Cryptol.ModuleSystem.Renamer.Error.DepName
instance GHC.Classes.Ord Cryptol.ModuleSystem.Renamer.Error.DepName
instance GHC.Classes.Eq Cryptol.ModuleSystem.Renamer.Error.DepName
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Renamer.Error.RenamerError
instance GHC.Generics.Generic Cryptol.ModuleSystem.Renamer.Error.RenamerError
instance GHC.Show.Show Cryptol.ModuleSystem.Renamer.Error.RenamerError
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Renamer.Error.RenamerWarning
instance GHC.Generics.Generic Cryptol.ModuleSystem.Renamer.Error.RenamerWarning
instance GHC.Show.Show Cryptol.ModuleSystem.Renamer.Error.RenamerWarning
instance GHC.Classes.Eq Cryptol.ModuleSystem.Renamer.Error.RenamerWarning
instance GHC.Classes.Ord Cryptol.ModuleSystem.Renamer.Error.RenamerWarning
instance Cryptol.Utils.PP.PP Cryptol.ModuleSystem.Renamer.Error.RenamerWarning
instance Cryptol.Utils.PP.PP Cryptol.ModuleSystem.Renamer.Error.RenamerError
instance Cryptol.Utils.PP.PP Cryptol.ModuleSystem.Renamer.Error.DepName
module Cryptol.ModuleSystem.Interface
type Iface = IfaceG ModName
-- | The resulting interface generated by a module that has been
-- typechecked.
data IfaceG mname
Iface :: !mname -> IfaceDecls -> IfaceDecls -> IfaceParams -> IfaceG mname
-- | Module name
[ifModName] :: IfaceG mname -> !mname
-- | Exported definitions
[ifPublic] :: IfaceG mname -> IfaceDecls
-- | Private defintiions
[ifPrivate] :: IfaceG mname -> IfaceDecls
-- | Uninterpreted constants (aka module params)
[ifParams] :: IfaceG mname -> IfaceParams
data IfaceDecls
IfaceDecls :: Map Name IfaceTySyn -> Map Name IfaceNewtype -> Map Name IfaceAbstractType -> Map Name IfaceDecl -> !Map Name (IfaceG Name) -> IfaceDecls
[ifTySyns] :: IfaceDecls -> Map Name IfaceTySyn
[ifNewtypes] :: IfaceDecls -> Map Name IfaceNewtype
[ifAbstractTypes] :: IfaceDecls -> Map Name IfaceAbstractType
[ifDecls] :: IfaceDecls -> Map Name IfaceDecl
[ifModules] :: IfaceDecls -> !Map Name (IfaceG Name)
type IfaceTySyn = TySyn
ifTySynName :: TySyn -> Name
type IfaceNewtype = Newtype
data IfaceDecl
IfaceDecl :: !Name -> Schema -> [Pragma] -> Bool -> Maybe Fixity -> Maybe Text -> IfaceDecl
-- | Name of thing
[ifDeclName] :: IfaceDecl -> !Name
-- | Type
[ifDeclSig] :: IfaceDecl -> Schema
-- | Pragmas
[ifDeclPragmas] :: IfaceDecl -> [Pragma]
-- | Is this an infix thing
[ifDeclInfix] :: IfaceDecl -> Bool
-- | Fixity information
[ifDeclFixity] :: IfaceDecl -> Maybe Fixity
-- | Documentation
[ifDeclDoc] :: IfaceDecl -> Maybe Text
data IfaceParams
IfaceParams :: Map Name ModTParam -> [Located Prop] -> Map Name ModVParam -> IfaceParams
[ifParamTypes] :: IfaceParams -> Map Name ModTParam
-- | Constraints on param. types
[ifParamConstraints] :: IfaceParams -> [Located Prop]
[ifParamFuns] :: IfaceParams -> Map Name ModVParam
emptyIface :: mname -> IfaceG mname
-- | Produce a PrimMap from an interface.
--
-- NOTE: the map will expose both public and private names.
ifacePrimMap :: Iface -> PrimMap
noIfaceParams :: IfaceParams
isEmptyIfaceParams :: IfaceParams -> Bool
ifaceIsFunctor :: IfaceG mname -> Bool
-- | The public declarations in all modules, including nested The modules
-- field contains public functors Assumes that we are not a functor.
flatPublicIface :: IfaceG mname -> IfaceDecls
flatPublicDecls :: IfaceDecls -> IfaceDecls
filterIfaceDecls :: (Name -> Bool) -> IfaceDecls -> IfaceDecls
ifaceDeclsNames :: IfaceDecls -> Set Name
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Interface.IfaceParams
instance GHC.Generics.Generic Cryptol.ModuleSystem.Interface.IfaceParams
instance GHC.Show.Show Cryptol.ModuleSystem.Interface.IfaceParams
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Interface.IfaceDecl
instance GHC.Generics.Generic Cryptol.ModuleSystem.Interface.IfaceDecl
instance GHC.Show.Show Cryptol.ModuleSystem.Interface.IfaceDecl
instance Control.DeepSeq.NFData mname => Control.DeepSeq.NFData (Cryptol.ModuleSystem.Interface.IfaceG mname)
instance GHC.Generics.Generic (Cryptol.ModuleSystem.Interface.IfaceG mname)
instance GHC.Show.Show mname => GHC.Show.Show (Cryptol.ModuleSystem.Interface.IfaceG mname)
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Interface.IfaceDecls
instance GHC.Generics.Generic Cryptol.ModuleSystem.Interface.IfaceDecls
instance GHC.Show.Show Cryptol.ModuleSystem.Interface.IfaceDecls
instance GHC.Base.Semigroup Cryptol.ModuleSystem.Interface.IfaceDecls
instance GHC.Base.Monoid Cryptol.ModuleSystem.Interface.IfaceDecls
module Cryptol.ModuleSystem.Exports
modExports :: Ord name => ModuleG mname name -> ExportSpec name
exportedNames :: Ord name => TopDecl name -> [ExportSpec name]
names :: (a -> ([Located a'], b)) -> TopLevel a -> [TopLevel a']
newtype ExportSpec name
ExportSpec :: Map Namespace (Set name) -> ExportSpec name
exportName :: Ord name => Namespace -> TopLevel name -> ExportSpec name
exported :: Namespace -> ExportSpec name -> Set name
-- | Add a binding name to the export list, if it should be exported.
exportBind :: Ord name => TopLevel name -> ExportSpec name
-- | Add a type synonym name to the export list, if it should be exported.
exportType :: Ord name => TopLevel name -> ExportSpec name
isExported :: Ord name => Namespace -> name -> ExportSpec name -> Bool
-- | Check to see if a binding is exported.
isExportedBind :: Ord name => name -> ExportSpec name -> Bool
-- | Check to see if a type synonym is exported.
isExportedType :: Ord name => name -> ExportSpec name -> Bool
instance GHC.Generics.Generic (Cryptol.ModuleSystem.Exports.ExportSpec name)
instance GHC.Show.Show name => GHC.Show.Show (Cryptol.ModuleSystem.Exports.ExportSpec name)
instance Control.DeepSeq.NFData name => Control.DeepSeq.NFData (Cryptol.ModuleSystem.Exports.ExportSpec name)
instance GHC.Classes.Ord name => GHC.Base.Semigroup (Cryptol.ModuleSystem.Exports.ExportSpec name)
instance GHC.Classes.Ord name => GHC.Base.Monoid (Cryptol.ModuleSystem.Exports.ExportSpec name)
module Cryptol.TypeCheck.AST
data DeclDef
DPrim :: DeclDef
DExpr :: Expr -> DeclDef
data Decl
Decl :: !Name -> Schema -> DeclDef -> [Pragma] -> !Bool -> Maybe Fixity -> Maybe Text -> Decl
[dName] :: Decl -> !Name
[dSignature] :: Decl -> Schema
[dDefinition] :: Decl -> DeclDef
[dPragmas] :: Decl -> [Pragma]
[dInfix] :: Decl -> !Bool
[dFixity] :: Decl -> Maybe Fixity
[dDoc] :: Decl -> Maybe Text
data DeclGroup
-- | Mutually recursive declarations
Recursive :: [Decl] -> DeclGroup
-- | Non-recursive declaration
NonRecursive :: Decl -> DeclGroup
data Match
-- | Type arguments are the length and element type of the sequence
-- expression
From :: Name -> Type -> Type -> Expr -> Match
Let :: Decl -> Match
data Expr
-- | List value (with type of elements)
EList :: [Expr] -> Type -> Expr
-- | Tuple value
ETuple :: [Expr] -> Expr
-- | Record value
ERec :: RecordMap Ident Expr -> Expr
-- | Elimination for tuplerecordlist
ESel :: Expr -> Selector -> Expr
-- | Change the value of a field. The included type gives the type of the
-- record being updated
ESet :: Type -> Expr -> Selector -> Expr -> Expr
-- | If-then-else
EIf :: Expr -> Expr -> Expr -> Expr
-- | List comprehensions The types cache the length of the sequence and its
-- element type.
EComp :: Type -> Type -> Expr -> [[Match]] -> Expr
-- | Use of a bound variable
EVar :: Name -> Expr
-- | Function Value
ETAbs :: TParam -> Expr -> Expr
-- | Type application
ETApp :: Expr -> Type -> Expr
-- | Function application
EApp :: Expr -> Expr -> Expr
-- | Function value
EAbs :: Name -> Type -> Expr -> Expr
-- | Source location information
ELocated :: Range -> Expr -> Expr
-- | Proof abstraction. Because we don't keep proofs around we don't need
-- to name the assumption, but we still need to record the assumption.
-- The assumption is the Type term, which should be of kind
-- KProp.
EProofAbs :: Prop -> Expr -> Expr
-- | If e : p => t, then EProofApp e : t, as long as
-- we can prove p.
--
-- We don't record the actual proofs, as they are not used for anything.
-- It may be nice to keep them around for sanity checking.
EProofApp :: Expr -> Expr
EWhere :: Expr -> [DeclGroup] -> Expr
type Module = ModuleG ModName
-- | A Cryptol module.
data ModuleG mname
Module :: !mname -> ExportSpec Name -> [Import] -> Map Name (IfaceG Name) -> Map Name ModTParam -> [Located Prop] -> Map Name ModVParam -> Map Name TySyn -> Map Name Newtype -> Map Name AbstractType -> [DeclGroup] -> Map Name (ModuleG Name) -> ModuleG mname
[mName] :: ModuleG mname -> !mname
[mExports] :: ModuleG mname -> ExportSpec Name
[mImports] :: ModuleG mname -> [Import]
-- | Interfaces of submodules, including functors. This is only the
-- directly nested modules. Info about more nested modules is in the
-- corresponding interface.
[mSubModules] :: ModuleG mname -> Map Name (IfaceG Name)
[mParamTypes] :: ModuleG mname -> Map Name ModTParam
[mParamConstraints] :: ModuleG mname -> [Located Prop]
[mParamFuns] :: ModuleG mname -> Map Name ModVParam
[mTySyns] :: ModuleG mname -> Map Name TySyn
[mNewtypes] :: ModuleG mname -> Map Name Newtype
[mPrimTypes] :: ModuleG mname -> Map Name AbstractType
[mDecls] :: ModuleG mname -> [DeclGroup]
[mFunctors] :: ModuleG mname -> Map Name (ModuleG Name)
emptyModule :: mname -> ModuleG mname
-- | Is this a parameterized module?
isParametrizedModule :: ModuleG mname -> Bool
groupDecls :: DeclGroup -> [Decl]
-- | Construct a primitive, given a map to the unique primitive name.
ePrim :: PrimMap -> PrimIdent -> Expr
-- | Make an expression that is error pre-applied to a type and a
-- message.
eError :: PrimMap -> Type -> String -> Expr
eString :: PrimMap -> String -> Expr
eChar :: PrimMap -> Char -> Expr
ppLam :: NameMap -> Int -> [TParam] -> [Prop] -> [(Name, Type)] -> Expr -> Doc
splitWhile :: (a -> Maybe (b, a)) -> a -> ([b], a)
splitAbs :: Expr -> Maybe ((Name, Type), Expr)
splitTAbs :: Expr -> Maybe (TParam, Expr)
splitProofAbs :: Expr -> Maybe (Prop, Expr)
splitTApp :: Expr -> Maybe (Type, Expr)
splitProofApp :: Expr -> Maybe ((), Expr)
-- | Deconstruct an expression, typically polymorphic, into the types and
-- proofs to which it is applied. Since we don't store the proofs, we
-- just return the number of proof applications. The first type is the
-- one closest to the expr.
splitExprInst :: Expr -> (Expr, [Type], Int)
data Name
-- | Built-in type functions. If you add additional user-visible
-- constructors, please update primTys in
-- Cryptol.Prims.Types.
data TFun
-- |
-- : Num -> Num -> Num
--
TCAdd :: TFun
-- |
-- : Num -> Num -> Num
--
TCSub :: TFun
-- |
-- : Num -> Num -> Num
--
TCMul :: TFun
-- |
-- : Num -> Num -> Num
--
TCDiv :: TFun
-- |
-- : Num -> Num -> Num
--
TCMod :: TFun
-- |
-- : Num -> Num -> Num
--
TCExp :: TFun
-- |
-- : Num -> Num
--
TCWidth :: TFun
-- |
-- : Num -> Num -> Num
--
TCMin :: TFun
-- |
-- : Num -> Num -> Num
--
TCMax :: TFun
-- |
-- : Num -> Num -> Num
--
TCCeilDiv :: TFun
-- |
-- : Num -> Num -> Num
--
TCCeilMod :: TFun
-- | : Num -> Num -> Num -> Num Example: [ 1, 5 .. 9
-- ] :: [lengthFromThenTo 1 5 9][b]
TCLenFromThenTo :: TFun
-- | Selectors are used for projecting from various components. Each
-- selector has an option spec to specify the shape of the thing that is
-- being selected. Currently, there is no surface syntax for list
-- selectors, but they are used during the desugaring of patterns.
data Selector
-- | Zero-based tuple selection. Optionally specifies the shape of the
-- tuple (one-based).
TupleSel :: Int -> Maybe Int -> Selector
-- | Record selection. Optionally specifies the shape of the record.
RecordSel :: Ident -> Maybe [Ident] -> Selector
-- | List selection. Optionally specifies the length of the list.
ListSel :: Int -> Maybe Int -> Selector
type Import = ImportG ModName
-- | An import declaration.
data ImportG mname
Import :: !mname -> Maybe ModName -> Maybe ImportSpec -> ImportG mname
[iModule] :: ImportG mname -> !mname
[iAs] :: ImportG mname -> Maybe ModName
[iSpec] :: ImportG mname -> Maybe ImportSpec
-- | The list of names following an import.
data ImportSpec
Hiding :: [Ident] -> ImportSpec
Only :: [Ident] -> ImportSpec
-- | Export information for a declaration.
data ExportType
Public :: ExportType
Private :: ExportType
newtype ExportSpec name
ExportSpec :: Map Namespace (Set name) -> ExportSpec name
-- | Check to see if a binding is exported.
isExportedBind :: Ord name => name -> ExportSpec name -> Bool
-- | Check to see if a type synonym is exported.
isExportedType :: Ord name => name -> ExportSpec name -> Bool
isExported :: Ord name => Namespace -> name -> ExportSpec name -> Bool
data Pragma
PragmaNote :: String -> Pragma
PragmaProperty :: Pragma
data Fixity
Fixity :: !Assoc -> !Int -> Fixity
[fAssoc] :: Fixity -> !Assoc
[fLevel] :: Fixity -> !Int
-- | A mapping from an identifier defined in some module to its real name.
data PrimMap
PrimMap :: Map PrimIdent Name -> Map PrimIdent Name -> PrimMap
[primDecls] :: PrimMap -> Map PrimIdent Name
[primTypes] :: PrimMap -> Map PrimIdent Name
instance Control.DeepSeq.NFData Cryptol.TypeCheck.AST.Match
instance GHC.Generics.Generic Cryptol.TypeCheck.AST.Match
instance GHC.Show.Show Cryptol.TypeCheck.AST.Match
instance GHC.Show.Show Cryptol.TypeCheck.AST.Decl
instance Control.DeepSeq.NFData Cryptol.TypeCheck.AST.Decl
instance GHC.Generics.Generic Cryptol.TypeCheck.AST.Decl
instance Control.DeepSeq.NFData Cryptol.TypeCheck.AST.DeclGroup
instance GHC.Generics.Generic Cryptol.TypeCheck.AST.DeclGroup
instance GHC.Show.Show Cryptol.TypeCheck.AST.DeclGroup
instance Control.DeepSeq.NFData Cryptol.TypeCheck.AST.Expr
instance GHC.Generics.Generic Cryptol.TypeCheck.AST.Expr
instance GHC.Show.Show Cryptol.TypeCheck.AST.Expr
instance Control.DeepSeq.NFData Cryptol.TypeCheck.AST.DeclDef
instance GHC.Generics.Generic Cryptol.TypeCheck.AST.DeclDef
instance GHC.Show.Show Cryptol.TypeCheck.AST.DeclDef
instance Control.DeepSeq.NFData mname => Control.DeepSeq.NFData (Cryptol.TypeCheck.AST.ModuleG mname)
instance GHC.Generics.Generic (Cryptol.TypeCheck.AST.ModuleG mname)
instance GHC.Show.Show mname => GHC.Show.Show (Cryptol.TypeCheck.AST.ModuleG mname)
instance Cryptol.Utils.PP.PP n => Cryptol.Utils.PP.PP (Cryptol.TypeCheck.AST.ModuleG n)
instance Cryptol.Utils.PP.PP n => Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames (Cryptol.TypeCheck.AST.ModuleG n))
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.AST.Expr)
instance Cryptol.Parser.Position.HasLoc Cryptol.TypeCheck.AST.Expr
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.AST.Expr
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.AST.Match)
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.AST.Match
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.AST.DeclGroup)
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.AST.DeclGroup
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.AST.Decl)
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.AST.DeclDef)
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.AST.Decl
module Cryptol.TypeCheck.TypeMap
data TypeMap a
TM :: Map TVar a -> Map TCon (List TypeMap a) -> Map [Ident] (List TypeMap a) -> Map Newtype (List TypeMap a) -> TypeMap a
[tvar] :: TypeMap a -> Map TVar a
[tcon] :: TypeMap a -> Map TCon (List TypeMap a)
[trec] :: TypeMap a -> Map [Ident] (List TypeMap a)
[tnewtype] :: TypeMap a -> Map Newtype (List TypeMap a)
type TypesMap = List TypeMap
class TrieMap m k | m -> k
emptyTM :: TrieMap m k => m a
nullTM :: TrieMap m k => m a -> Bool
lookupTM :: TrieMap m k => k -> m a -> Maybe a
alterTM :: TrieMap m k => k -> (Maybe a -> Maybe a) -> m a -> m a
unionTM :: TrieMap m k => (a -> a -> a) -> m a -> m a -> m a
toListTM :: TrieMap m k => m a -> [(k, a)]
mapMaybeWithKeyTM :: TrieMap m k => (k -> a -> Maybe b) -> m a -> m b
insertTM :: TrieMap m k => k -> a -> m a -> m a
insertWithTM :: TrieMap m k => (a -> a -> a) -> k -> a -> m a -> m a
membersTM :: TrieMap m k => m a -> [a]
mapTM :: TrieMap m k => (a -> b) -> m a -> m b
mapWithKeyTM :: TrieMap m k => (k -> a -> b) -> m a -> m b
mapMaybeTM :: TrieMap m k => (a -> Maybe b) -> m a -> m b
data List m a
L :: Maybe a -> m (List m a) -> List m a
[nil] :: List m a -> Maybe a
[cons] :: List m a -> m (List m a)
instance Data.Traversable.Traversable m => Data.Traversable.Traversable (Cryptol.TypeCheck.TypeMap.List m)
instance Data.Foldable.Foldable m => Data.Foldable.Foldable (Cryptol.TypeCheck.TypeMap.List m)
instance GHC.Base.Functor m => GHC.Base.Functor (Cryptol.TypeCheck.TypeMap.List m)
instance Data.Traversable.Traversable Cryptol.TypeCheck.TypeMap.TypeMap
instance Data.Foldable.Foldable Cryptol.TypeCheck.TypeMap.TypeMap
instance GHC.Base.Functor Cryptol.TypeCheck.TypeMap.TypeMap
instance Cryptol.TypeCheck.TypeMap.TrieMap Cryptol.TypeCheck.TypeMap.TypeMap Cryptol.TypeCheck.Type.Type
instance GHC.Show.Show a => GHC.Show.Show (Cryptol.TypeCheck.TypeMap.TypeMap a)
instance Cryptol.TypeCheck.TypeMap.TrieMap m a => Cryptol.TypeCheck.TypeMap.TrieMap (Cryptol.TypeCheck.TypeMap.List m) [a]
instance GHC.Classes.Ord a => Cryptol.TypeCheck.TypeMap.TrieMap (Data.Map.Internal.Map a) a
module Cryptol.TypeCheck.Solver.Utils
-- | All ways to split a type in the form: a + t1, where
-- a is a variable.
splitVarSummands :: Type -> [(TVar, Type)]
-- | Check if we can express a type in the form: a + t1.
splitVarSummand :: TVar -> Type -> Maybe Type
-- | Check if we can express a type in the form: k + t1, where
-- k is a constant > 0. This assumes that the type has been
-- simplified already, so that constants are floated to the left.
splitConstSummand :: Type -> Maybe (Integer, Type)
-- | Check if we can express a type in the form: k * t1, where
-- k is a constant > 1. This assumes that the type has been
-- simplified already, so that constants are floated to the left.
splitConstFactor :: Type -> Maybe (Integer, Type)
-- | An interval interpretation of types.
module Cryptol.TypeCheck.Solver.Numeric.Interval
-- | Only meaningful for numeric types
typeInterval :: Map TVar Interval -> Type -> Interval
tvarInterval :: Map TVar Interval -> TVar -> Interval
data IntervalUpdate
NoChange :: IntervalUpdate
InvalidInterval :: TVar -> IntervalUpdate
NewIntervals :: Map TVar Interval -> IntervalUpdate
updateInterval :: (TVar, Interval) -> Map TVar Interval -> IntervalUpdate
computePropIntervals :: Map TVar Interval -> [Prop] -> IntervalUpdate
-- | What we learn about variables from a single prop.
propInterval :: Map TVar Interval -> Prop -> [(TVar, Interval)]
data Interval
Interval :: Nat' -> Maybe Nat' -> Interval
-- | lower bound (inclusive)
[iLower] :: Interval -> Nat'
-- | upper bound (inclusive) If there is no upper bound, then all *natural*
-- numbers.
[iUpper] :: Interval -> Maybe Nat'
ppIntervals :: Map TVar Interval -> Doc
ppInterval :: Interval -> Doc
iIsExact :: Interval -> Maybe Nat'
iIsFin :: Interval -> Bool
-- | Finite positive number. [1 .. inf).
iIsPosFin :: Interval -> Bool
-- | Returns True when the intervals definitely overlap, and
-- False otherwise.
iOverlap :: Interval -> Interval -> Bool
-- | Intersect two intervals, yielding a new one that describes the space
-- where they overlap. If the two intervals are disjoint, the result will
-- be Nothing.
iIntersect :: Interval -> Interval -> Maybe Interval
-- | Any value
iAny :: Interval
-- | Any finite value
iAnyFin :: Interval
-- | Exactly this value
iConst :: Nat' -> Interval
iAdd :: Interval -> Interval -> Interval
iMul :: Interval -> Interval -> Interval
iExp :: Interval -> Interval -> Interval
iMin :: Interval -> Interval -> Interval
iMax :: Interval -> Interval -> Interval
iSub :: Interval -> Interval -> Interval
iDiv :: Interval -> Interval -> Interval
iMod :: Interval -> Interval -> Interval
iCeilDiv :: Interval -> Interval -> Interval
iCeilMod :: Interval -> Interval -> Interval
iWidth :: Interval -> Interval
iLenFromThenTo :: Interval -> Interval -> Interval -> Interval
instance GHC.Show.Show Cryptol.TypeCheck.Solver.Numeric.Interval.Interval
instance GHC.Classes.Eq Cryptol.TypeCheck.Solver.Numeric.Interval.Interval
instance GHC.Show.Show Cryptol.TypeCheck.Solver.Numeric.Interval.IntervalUpdate
module Cryptol.TypeCheck.Solver.Types
data Ctxt
SolverCtxt :: Map TVar Interval -> Set Prop -> Ctxt
[intervals] :: Ctxt -> Map TVar Interval
[saturatedAsmps] :: Ctxt -> Set Prop
data Solved
-- | Solved, assuming the sub-goals.
SolvedIf :: [Prop] -> Solved
-- | We could not solve the goal.
Unsolved :: Solved
-- | The goal can never be solved.
Unsolvable :: Solved
elseTry :: Solved -> Solved -> Solved
solveOpts :: [Solved] -> Solved
matchThen :: Maybe a -> (a -> Solved) -> Solved
guarded :: Bool -> Solved -> Solved
instance GHC.Show.Show Cryptol.TypeCheck.Solver.Types.Solved
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Solver.Types.Solved
instance GHC.Base.Semigroup Cryptol.TypeCheck.Solver.Types.Ctxt
instance GHC.Base.Monoid Cryptol.TypeCheck.Solver.Types.Ctxt
-- | Solving class constraints.
module Cryptol.TypeCheck.Solver.Class
-- | Solve a Zero constraint by instance, if possible.
solveZeroInst :: Type -> Solved
-- | Solve a Logic constraint by instance, if possible.
solveLogicInst :: Type -> Solved
-- | Solve a Ring constraint by instance, if possible.
solveRingInst :: Type -> Solved
-- | Solve a Field constraint by instance, if possible.
solveFieldInst :: Type -> Solved
-- | Solve an Integral constraint by instance, if possible.
solveIntegralInst :: Type -> Solved
-- | Solve a Round constraint by instance, if possible.
solveRoundInst :: Type -> Solved
-- | Solve Eq constraints.
solveEqInst :: Type -> Solved
-- | Solve Cmp constraints.
solveCmpInst :: Type -> Solved
-- | Solve SignedCmp constraints.
solveSignedCmpInst :: Type -> Solved
-- | Solve Literal constraints.
solveLiteralInst :: Type -> Type -> Solved
-- | Solve Literal constraints.
solveLiteralLessThanInst :: Type -> Type -> Solved
-- | Solving fractional literal constraints.
solveFLiteralInst :: Type -> Type -> Type -> Type -> Solved
-- | This places constraints on the floating point numbers that we can work
-- with. This is a bit of an odd check, as it is really a limitiation of
-- the backend, and not the language itself.
--
-- On the other hand, it helps us give sane results if one accidentally
-- types a polymorphic float at the REPL. Hopefully, most users will
-- stick to particular FP sizes, so this should be quite transparent.
solveValidFloat :: Type -> Type -> Solved
-- | Simplification of fin constraints.
module Cryptol.TypeCheck.Solver.Numeric.Fin
cryIsFin :: Ctxt -> Prop -> Solved
cryIsFinType :: Ctxt -> Type -> Solved
module Cryptol.TypeCheck.Solver.Numeric
-- | Try to solve t1 = t2
cryIsEqual :: Ctxt -> Type -> Type -> Solved
-- | Try to solve t1 /= t2
cryIsNotEqual :: Ctxt -> Type -> Type -> Solved
-- | Try to solve t1 >= t2
cryIsGeq :: Ctxt -> Type -> Type -> Solved
cryIsPrime :: Ctxt -> Type -> Solved
primeTable :: Integer :->: Bool
module Cryptol.TypeCheck.SimpleSolver
simplify :: Ctxt -> Prop -> Prop
simplifyStep :: Ctxt -> Prop -> Solved
module Cryptol.TypeCheck.Subst
-- | A Subst value represents a substitution that maps each
-- TVar to a Type.
--
-- Invariant 1: If there is a mapping from TVFree _ _ tps _ to a
-- type t, then t must not mention (directly or
-- indirectly) any type parameter that is not in tps. In
-- particular, if t contains a variable TVFree _ _ tps2
-- _, then tps2 must be a subset of tps. This
-- ensures that applying the substitution will not permit any type
-- parameter to escape from its scope.
--
-- Invariant 2: The substitution must be idempotent, in that applying a
-- substitution to any Type in the map should leave that
-- Type unchanged. In other words, Type values in the range
-- of a Subst should not mention any TVar in the domain of
-- the Subst. In particular, this implies that a substitution must
-- not contain any recursive variable mappings.
--
-- Invariant 3: The substitution must be kind correct: Each TVar
-- in the substitution must map to a Type of the same kind.
data Subst
emptySubst :: Subst
-- | Reasons to reject a single-variable substitution.
data SubstError
-- | TVar maps to a type containing the same variable.
SubstRecursive :: SubstError
-- | TVar maps to a type containing one or more out-of-scope bound
-- variables.
SubstEscaped :: [TParam] -> SubstError
-- | TVar maps to a type with a different kind.
SubstKindMismatch :: Kind -> Kind -> SubstError
singleSubst :: TVar -> Type -> Either SubstError Subst
singleTParamSubst :: TParam -> Type -> Subst
uncheckedSingleSubst :: TVar -> Type -> Subst
(@@) :: Subst -> Subst -> Subst
-- | A defaulting substitution maps all otherwise-unmapped free variables
-- to a kind-appropriate default type (Bit for value types and
-- 0 for numeric types).
defaultingSubst :: Subst -> Subst
-- | Makes a substitution out of a list. WARNING: We do not validate the
-- list in any way, so the caller should ensure that we end up with a
-- valid (e.g., idempotent) substitution.
listSubst :: [(TVar, Type)] -> Subst
-- | Makes a substitution out of a list. WARNING: We do not validate the
-- list in any way, so the caller should ensure that we end up with a
-- valid (e.g., idempotent) substitution.
listParamSubst :: [(TParam, Type)] -> Subst
isEmptySubst :: Subst -> Bool
class FVS t
fvs :: FVS t => t -> Set TVar
-- | Apply a substitution. Returns Nothing if nothing changed.
apSubstMaybe :: Subst -> Type -> Maybe Type
class TVars t
-- | Replaces free variables. To prevent space leaks when used with large
-- Subst values, every instance of apSubst should satisfy a
-- strictness property: Forcing evaluation of apSubst s x
-- should also force the evaluation of all recursive calls to
-- apSubst s. This ensures that unevaluated thunks will
-- not cause Subst values to be retained on the heap.
apSubst :: TVars t => Subst -> t -> t
-- | Apply the substitution to the keys of a type map.
apSubstTypeMapKeys :: Subst -> TypeMap a -> TypeMap a
substBinds :: Subst -> Set TVar
applySubstToVar :: Subst -> TVar -> Maybe Type
substToList :: Subst -> [(TVar, Type)]
-- | Strict variant of fmap.
fmap' :: Traversable t => (a -> b) -> t a -> t b
-- | Left-associative variant of the strict application operator $!.
(!$) :: (a -> b) -> a -> b
infixl 0 !$
-- | Left-associative variant of the application operator $.
(.$) :: (a -> b) -> a -> b
infixl 0 .$
instance GHC.Show.Show Cryptol.TypeCheck.Subst.Subst
instance Data.Traversable.Traversable Cryptol.TypeCheck.Subst.Done
instance Data.Foldable.Foldable Cryptol.TypeCheck.Subst.Done
instance GHC.Base.Functor Cryptol.TypeCheck.Subst.Done
instance Cryptol.TypeCheck.Subst.TVars t => Cryptol.TypeCheck.Subst.TVars (GHC.Maybe.Maybe t)
instance Cryptol.TypeCheck.Subst.TVars t => Cryptol.TypeCheck.Subst.TVars [t]
instance (Cryptol.TypeCheck.Subst.TVars s, Cryptol.TypeCheck.Subst.TVars t) => Cryptol.TypeCheck.Subst.TVars (s, t)
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.Type.Type
instance (Data.Traversable.Traversable m, Cryptol.TypeCheck.Subst.TVars a) => Cryptol.TypeCheck.Subst.TVars (Cryptol.TypeCheck.TypeMap.List m a)
instance Cryptol.TypeCheck.Subst.TVars a => Cryptol.TypeCheck.Subst.TVars (Cryptol.TypeCheck.TypeMap.TypeMap a)
instance Cryptol.TypeCheck.Subst.TVars a => Cryptol.TypeCheck.Subst.TVars (Data.Map.Internal.Map k a)
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.Type.TySyn
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.Type.Schema
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.AST.Expr
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.AST.Match
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.AST.DeclGroup
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.AST.Decl
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.AST.DeclDef
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.AST.Module
instance GHC.Base.Applicative Cryptol.TypeCheck.Subst.Done
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.Subst.Subst)
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Subst.Subst
module Cryptol.TypeCheck.Unify
-- | The most general unifier is a substitution and a set of constraints on
-- bound variables.
type MGU = (Subst, [Prop])
type Result a = Writer [(Path, UnificationError)] a
runResult :: Result a -> (a, [(Path, UnificationError)])
data UnificationError
UniTypeMismatch :: Type -> Type -> UnificationError
UniKindMismatch :: Kind -> Kind -> UnificationError
UniTypeLenMismatch :: Int -> Int -> UnificationError
UniRecursive :: TVar -> Type -> UnificationError
UniNonPolyDepends :: TVar -> [TParam] -> UnificationError
UniNonPoly :: TVar -> Type -> UnificationError
uniError :: Path -> UnificationError -> Result MGU
newtype Path
Path :: [PathElement] -> Path
data PathElement
TConArg :: TC -> Int -> PathElement
TNewtypeArg :: Newtype -> Int -> PathElement
TRecArg :: Ident -> PathElement
rootPath :: Path
isRootPath :: Path -> Bool
extPath :: Path -> PathElement -> Path
emptyMGU :: MGU
doMGU :: Type -> Type -> Result MGU
mgu :: Path -> Type -> Type -> Result MGU
mguMany :: Path -> [Path] -> [Type] -> [Type] -> Result MGU
bindVar :: Path -> TVar -> Type -> Result MGU
ppPathEl :: PathElement -> Int -> (Int -> Doc) -> Doc
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Unify.PathElement
instance GHC.Generics.Generic Cryptol.TypeCheck.Unify.PathElement
instance GHC.Show.Show Cryptol.TypeCheck.Unify.PathElement
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Unify.Path
instance GHC.Generics.Generic Cryptol.TypeCheck.Unify.Path
instance GHC.Show.Show Cryptol.TypeCheck.Unify.Path
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Unify.Path
module Cryptol.TypeCheck.TypeOf
-- | Given a typing environment and an expression, compute the type of the
-- expression as quickly as possible, assuming that the expression is
-- well formed with correct type annotations.
fastTypeOf :: Map Name Schema -> Expr -> Type
fastSchemaOf :: Map Name Schema -> Expr -> Schema
-- | Look for opportunity to solve goals by instantiating variables.
module Cryptol.TypeCheck.Solver.Improve
-- | Improvements from a bunch of propositions. Invariant: the substitions
-- should be already applied to the new sub-goals, if any.
improveProps :: Bool -> Ctxt -> [Prop] -> Match (Subst, [Prop])
-- | Improvements from a proposition. Invariant: the substitions should be
-- already applied to the new sub-goals, if any.
improveProp :: Bool -> Ctxt -> Prop -> Match (Subst, [Prop])
improveLit :: Bool -> Prop -> Match (Subst, [Prop])
-- | Improvements from equality constraints. Invariant: the substitions
-- should be already applied to the new sub-goals, if any.
improveEq :: Bool -> Ctxt -> Prop -> Match (Subst, [Prop])
module Cryptol.TypeCheck.Parseable
class ShowParseable t
showParseable :: ShowParseable t => t -> Doc Void
($$) :: Doc a -> Doc a -> Doc a
infixl 5 $$
text :: String -> Doc a
int :: Int -> Doc a
maybeNameDoc :: Maybe Name -> Doc Void
class ShowParseable t
showParseable :: ShowParseable t => t -> Doc Void
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.TypeCheck.AST.Expr
instance (Cryptol.TypeCheck.Parseable.ShowParseable a, Cryptol.TypeCheck.Parseable.ShowParseable b) => Cryptol.TypeCheck.Parseable.ShowParseable (a, b)
instance Cryptol.TypeCheck.Parseable.ShowParseable GHC.Types.Int
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.Utils.Ident.Ident
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.TypeCheck.Type.Type
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.Parser.Selector.Selector
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.TypeCheck.AST.Match
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.TypeCheck.AST.Decl
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.TypeCheck.AST.DeclDef
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.TypeCheck.AST.DeclGroup
instance Cryptol.TypeCheck.Parseable.ShowParseable a => Cryptol.TypeCheck.Parseable.ShowParseable [a]
instance Cryptol.TypeCheck.Parseable.ShowParseable a => Cryptol.TypeCheck.Parseable.ShowParseable (GHC.Maybe.Maybe a)
instance Cryptol.TypeCheck.Parseable.ShowParseable a => Cryptol.TypeCheck.Parseable.ShowParseable (Cryptol.Parser.Position.Located a)
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.TypeCheck.Type.TParam
instance Cryptol.TypeCheck.Parseable.ShowParseable Cryptol.ModuleSystem.Name.Name
module Cryptol.TypeCheck.Interface
mkIfaceDecl :: Decl -> IfaceDecl
-- | Generate an Iface from a typechecked module.
genIface :: ModuleG mname -> IfaceG mname
-- | This module contains types used during type inference.
module Cryptol.TypeCheck.InferTypes
data SolverConfig
SolverConfig :: FilePath -> [String] -> Int -> [FilePath] -> SolverConfig
-- | The SMT solver to invoke
[solverPath] :: SolverConfig -> FilePath
-- | Additional arguments to pass to the solver
[solverArgs] :: SolverConfig -> [String]
-- | How verbose to be when type-checking
[solverVerbose] :: SolverConfig -> Int
-- | Look for the solver prelude in these locations.
[solverPreludePath] :: SolverConfig -> [FilePath]
-- | A default configuration for using Z3, where the solver prelude is
-- expected to be found in the given search path.
defaultSolverConfig :: [FilePath] -> SolverConfig
-- | The types of variables in the environment.
data VarType
-- | Known type
ExtVar :: Schema -> VarType
-- | Part of current SCC. The expression will replace the variable, after
-- we are done with the SCC. In this way a variable that gets generalized
-- is replaced with an appropriate instantiation of itself.
CurSCC :: Expr -> Type -> VarType
data Goals
Goals :: Set Goal -> Set Prop -> Map TVar LitGoal -> Map TVar LitGoal -> Goals
-- | A bunch of goals, not including the ones in literalGoals.
[goalSet] :: Goals -> Set Goal
-- | The set of nonliteral goals, saturated by all superclass implications
[saturatedPropSet] :: Goals -> Set Prop
-- | An entry (a,t) corresponds to Literal t a.
[literalGoals] :: Goals -> Map TVar LitGoal
-- | An entry (a,t) corresponds to LiteralLessThan t a.
[literalLessThanGoals] :: Goals -> Map TVar LitGoal
-- | This abuses the type Goal a bit. The goal field contains
-- only the numeric part of the Literal constraint. For example, (a,
-- Goal { goal = t }) representats the goal for Literal t a
type LitGoal = Goal
litGoalToGoal :: (TVar, LitGoal) -> Goal
goalToLitGoal :: Goal -> Maybe (TVar, LitGoal)
litLessThanGoalToGoal :: (TVar, LitGoal) -> Goal
goalToLitLessThanGoal :: Goal -> Maybe (TVar, LitGoal)
emptyGoals :: Goals
nullGoals :: Goals -> Bool
fromGoals :: Goals -> [Goal]
goalsFromList :: [Goal] -> Goals
insertGoal :: Goal -> Goals -> Goals
-- | Something that we need to find evidence for.
data Goal
Goal :: ConstraintSource -> Range -> Prop -> Goal
-- | What it is about
[goalSource] :: Goal -> ConstraintSource
-- | Part of source code that caused goal
[goalRange] :: Goal -> Range
-- | What needs to be proved
[goal] :: Goal -> Prop
data HasGoal
HasGoal :: !Int -> Goal -> HasGoal
[hasName] :: HasGoal -> !Int
[hasGoal] :: HasGoal -> Goal
-- | A solution for a HasGoal
data HasGoalSln
HasGoalSln :: (Expr -> Expr) -> (Expr -> Expr -> Expr) -> HasGoalSln
-- | Select a specific field from the input expsression.
[hasDoSelect] :: HasGoalSln -> Expr -> Expr
-- | Set a field of the first expression to the second expression
[hasDoSet] :: HasGoalSln -> Expr -> Expr -> Expr
-- | Delayed implication constraints, arising from user-specified type
-- sigs.
data DelayedCt
DelayedCt :: Maybe Name -> [TParam] -> [Prop] -> [Goal] -> DelayedCt
-- | Signature that gave rise to this constraint Nothing means module
-- top-level
[dctSource] :: DelayedCt -> Maybe Name
[dctForall] :: DelayedCt -> [TParam]
[dctAsmps] :: DelayedCt -> [Prop]
[dctGoals] :: DelayedCt -> [Goal]
-- | Information about how a constraint came to be, used in error
-- reporting.
data ConstraintSource
-- | Computing shape of list comprehension
CtComprehension :: ConstraintSource
-- | Use of a split pattern
CtSplitPat :: ConstraintSource
-- | A type signature in a pattern or expression
CtTypeSig :: ConstraintSource
-- | Instantiation of this expression
CtInst :: Expr -> ConstraintSource
CtSelector :: ConstraintSource
CtExactType :: ConstraintSource
CtEnumeration :: ConstraintSource
-- | Just defaulting on the command line
CtDefaulting :: ConstraintSource
-- | Use of a partial type function.
CtPartialTypeFun :: Name -> ConstraintSource
CtImprovement :: ConstraintSource
-- | Constraints arising from type-checking patterns
CtPattern :: TypeSource -> ConstraintSource
-- | Instantiating a parametrized module
CtModuleInstance :: ModName -> ConstraintSource
selSrc :: Selector -> TypeSource
-- | For use in error messages
cppKind :: Kind -> Doc
addTVarsDescsAfter :: FVS t => NameMap -> t -> Doc -> Doc
addTVarsDescsBefore :: FVS t => NameMap -> t -> Doc -> Doc
ppUse :: Expr -> Doc
instance Control.DeepSeq.NFData Cryptol.TypeCheck.InferTypes.SolverConfig
instance GHC.Generics.Generic Cryptol.TypeCheck.InferTypes.SolverConfig
instance GHC.Show.Show Cryptol.TypeCheck.InferTypes.SolverConfig
instance Control.DeepSeq.NFData Cryptol.TypeCheck.InferTypes.ConstraintSource
instance GHC.Generics.Generic Cryptol.TypeCheck.InferTypes.ConstraintSource
instance GHC.Show.Show Cryptol.TypeCheck.InferTypes.ConstraintSource
instance Control.DeepSeq.NFData Cryptol.TypeCheck.InferTypes.Goal
instance GHC.Generics.Generic Cryptol.TypeCheck.InferTypes.Goal
instance GHC.Show.Show Cryptol.TypeCheck.InferTypes.Goal
instance Control.DeepSeq.NFData Cryptol.TypeCheck.InferTypes.DelayedCt
instance GHC.Generics.Generic Cryptol.TypeCheck.InferTypes.DelayedCt
instance GHC.Show.Show Cryptol.TypeCheck.InferTypes.DelayedCt
instance GHC.Show.Show Cryptol.TypeCheck.InferTypes.HasGoal
instance GHC.Show.Show Cryptol.TypeCheck.InferTypes.Goals
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.InferTypes.Goals
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.InferTypes.HasGoal
instance Cryptol.TypeCheck.Type.FVS Cryptol.TypeCheck.InferTypes.DelayedCt
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.InferTypes.DelayedCt
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.InferTypes.DelayedCt)
instance GHC.Classes.Eq Cryptol.TypeCheck.InferTypes.Goal
instance GHC.Classes.Ord Cryptol.TypeCheck.InferTypes.Goal
instance Cryptol.TypeCheck.Type.FVS Cryptol.TypeCheck.InferTypes.Goal
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.InferTypes.Goal
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.InferTypes.Goal)
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.InferTypes.ConstraintSource
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.InferTypes.ConstraintSource
module Cryptol.TypeCheck.Solver.SMT
-- | An SMT solver packed with a logger for debugging.
data Solver
data SolverConfig
-- | Execute a computation with a fresh solver instance.
withSolver :: IO () -> SolverConfig -> (Solver -> IO a) -> IO a
-- | Start a fresh solver instance
startSolver :: IO () -> SolverConfig -> IO Solver
-- | Shut down a solver instance
stopSolver :: Solver -> IO ()
-- | Assumes no And
isNumeric :: Prop -> Bool
resetSolver :: Solver -> SolverConfig -> IO ()
debugBlock :: Solver -> String -> IO a -> IO a
debugLog :: DebugLog t => Solver -> t -> IO ()
-- | Returns goals that were not proved
proveImp :: Solver -> [Prop] -> [Goal] -> IO [Goal]
-- | Check if the given goals are known to be unsolvable.
checkUnsolvable :: Solver -> [Goal] -> IO Bool
tryGetModel :: Solver -> [TVar] -> [Prop] -> IO (Maybe [(TVar, Nat')])
shrinkModel :: Solver -> [TVar] -> [Prop] -> [(TVar, Nat')] -> IO [(TVar, Nat')]
instance Cryptol.TypeCheck.Solver.SMT.Mk ()
instance Cryptol.TypeCheck.Solver.SMT.Mk GHC.Integer.Type.Integer
instance Cryptol.TypeCheck.Solver.SMT.Mk Cryptol.TypeCheck.Type.TVar
instance Cryptol.TypeCheck.Solver.SMT.Mk Cryptol.TypeCheck.Type.Type
instance Cryptol.TypeCheck.Solver.SMT.Mk (Cryptol.TypeCheck.Type.Type, Cryptol.TypeCheck.Type.Type)
instance Cryptol.TypeCheck.Solver.SMT.Mk (Cryptol.TypeCheck.Type.Type, Cryptol.TypeCheck.Type.Type, Cryptol.TypeCheck.Type.Type)
instance Cryptol.TypeCheck.Solver.SMT.DebugLog GHC.Types.Char
instance Cryptol.TypeCheck.Solver.SMT.DebugLog a => Cryptol.TypeCheck.Solver.SMT.DebugLog [a]
instance Cryptol.TypeCheck.Solver.SMT.DebugLog a => Cryptol.TypeCheck.Solver.SMT.DebugLog (GHC.Maybe.Maybe a)
instance Cryptol.TypeCheck.Solver.SMT.DebugLog Cryptol.Utils.PP.Doc
instance Cryptol.TypeCheck.Solver.SMT.DebugLog Cryptol.TypeCheck.Type.Type
instance Cryptol.TypeCheck.Solver.SMT.DebugLog Cryptol.TypeCheck.InferTypes.Goal
instance Cryptol.TypeCheck.Solver.SMT.DebugLog Cryptol.TypeCheck.Subst.Subst
module Cryptol.TypeCheck.Error
cleanupErrors :: [(Range, Error)] -> [(Range, Error)]
-- | Should the first error suppress the next one.
subsumes :: (Range, Error) -> (Range, Error) -> Bool
data Warning
DefaultingKind :: TParam Name -> Kind -> Warning
DefaultingWildType :: Kind -> Warning
DefaultingTo :: !TVarInfo -> Type -> Warning
-- | Various errors that might happen during type checking/inference
data Error
-- | Expected kind, inferred kind
KindMismatch :: Maybe TypeSource -> Kind -> Kind -> Error
-- | Number of extra parameters, kind of result (which should not be of the
-- form _ -> _)
TooManyTypeParams :: Int -> Kind -> Error
-- | A type variable was applied to some arguments.
TyVarWithParams :: Error
-- | Type-synonym, number of extra params
TooManyTySynParams :: Name -> Int -> Error
-- | Who is missing params, number of missing params
TooFewTyParams :: Name -> Int -> Error
-- | The type synonym declarations are recursive
RecursiveTypeDecls :: [Name] -> Error
-- | Expected type, inferred type
TypeMismatch :: TypeSource -> Path -> Type -> Type -> Error
-- | Unification results in a recursive type
RecursiveType :: TypeSource -> Path -> Type -> Type -> Error
-- | A constraint that we could not solve, usually because there are some
-- left-over variables that we could not infer.
UnsolvedGoals :: [Goal] -> Error
-- | A constraint that we could not solve and we know it is impossible to
-- do it.
UnsolvableGoals :: [Goal] -> Error
-- | A constraint (with context) that we could not solve
UnsolvedDelayedCt :: DelayedCt -> Error
-- | Type wild cards are not allowed in this context (e.g., definitions of
-- type synonyms).
UnexpectedTypeWildCard :: Error
-- | Unification variable depends on quantified variables that are not in
-- scope.
TypeVariableEscaped :: TypeSource -> Path -> Type -> [TParam] -> Error
-- | Quantified type variables (of kind *) need to match the given type, so
-- it does not work for all types.
NotForAll :: TypeSource -> Path -> TVar -> Type -> Error
-- | Too many positional type arguments, in an explicit type instantiation
TooManyPositionalTypeParams :: Error
-- | Kind other than * or # given to parameter of type
-- synonym, newtype, function signature, etc.
BadParameterKind :: TParam -> Kind -> Error
CannotMixPositionalAndNamedTypeParams :: Error
UndefinedTypeParameter :: Located Ident -> Error
RepeatedTypeParameter :: Ident -> [Range] -> Error
-- | Could not determine the value of a numeric type variable, but we know
-- it must be at least as large as the given type (or unconstrained, if
-- Nothing).
AmbiguousSize :: TVarInfo -> Maybe Type -> Error
-- | Bare expression of the form `{_}
BareTypeApp :: Error
UndefinedExistVar :: Name -> Error
TypeShadowing :: String -> Name -> String -> Error
MissingModTParam :: Located Ident -> Error
MissingModVParam :: Located Ident -> Error
-- | This is for errors that don't fit other cateogories. We should not use
-- it much, and is generally to be used for transient errors, which are
-- due to incomplete implementation.
TemporaryError :: Doc -> Error
-- | When we have multiple errors on the same location, we show only the
-- ones with the has highest rating according to this function.
errorImportance :: Error -> Int
explainUnsolvable :: NameMap -> [Goal] -> Doc
-- | This picks the names to use when showing errors and warnings.
computeFreeVarNames :: [(Range, Warning)] -> [(Range, Error)] -> NameMap
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Error.Warning
instance GHC.Generics.Generic Cryptol.TypeCheck.Error.Warning
instance GHC.Show.Show Cryptol.TypeCheck.Error.Warning
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Error.Error
instance GHC.Generics.Generic Cryptol.TypeCheck.Error.Error
instance GHC.Show.Show Cryptol.TypeCheck.Error.Error
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.Error.Error
instance Cryptol.TypeCheck.Type.FVS Cryptol.TypeCheck.Error.Error
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Error.Error
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.Error.Error)
instance Cryptol.TypeCheck.Subst.TVars Cryptol.TypeCheck.Error.Warning
instance Cryptol.TypeCheck.Type.FVS Cryptol.TypeCheck.Error.Warning
instance Cryptol.Utils.PP.PP Cryptol.TypeCheck.Error.Warning
instance Cryptol.Utils.PP.PP (Cryptol.TypeCheck.PP.WithNames Cryptol.TypeCheck.Error.Warning)
module Cryptol.TypeCheck.Monad
-- | This is what's returned when we lookup variables during kind checking.
data LkpTyVar
-- | Locally bound variable.
TLocalVar :: TParam -> Maybe Kind -> LkpTyVar
-- | An outer binding.
TOuterVar :: TParam -> LkpTyVar
data KRW
KRW :: Map Name Kind -> [(ConstraintSource, [Prop])] -> KRW
-- | kinds of (known) vars.
[typeParams] :: KRW -> Map Name Kind
[kCtrs] :: KRW -> [(ConstraintSource, [Prop])]
-- | Do we allow wild cards in the given context.
data AllowWildCards
AllowWildCards :: AllowWildCards
NoWildCards :: AllowWildCards
data KRO
KRO :: Map Name TParam -> AllowWildCards -> KRO
-- | lazy map, with tparams.
[lazyTParams] :: KRO -> Map Name TParam
-- | are type-wild cards allowed?
[allowWild] :: KRO -> AllowWildCards
newtype KindM a
KM :: ReaderT KRO (StateT KRW InferM) a -> KindM a
[unKM] :: KindM a -> ReaderT KRO (StateT KRW InferM) a
-- | Read-write component of the monad.
data RW
RW :: ![(Range, Error)] -> ![(Range, Warning)] -> !Subst -> [Map Name Type] -> Map Int HasGoalSln -> !NameSeeds -> !Goals -> ![HasGoal] -> ![ModuleG ScopeName] -> !Map Name Schema -> !Supply -> RW
-- | Collected errors
[iErrors] :: RW -> ![(Range, Error)]
-- | Collected warnings
[iWarnings] :: RW -> ![(Range, Warning)]
-- | Accumulated substitution
[iSubst] :: RW -> !Subst
-- | These keeps track of what existential type variables are available.
-- When we start checking a function, we push a new scope for its
-- arguments, and we pop it when we are done checking the function body.
-- The front element of the list is the current scope, which is the only
-- thing that will be modified, as follows. When we encounter a
-- existential type variable: 1. we look in all scopes to see if it is
-- already defined. 2. if it was not defined, we create a fresh type
-- variable, and we add it to the current scope. 3. it is an error if we
-- encounter an existential variable but we have no current scope.
[iExistTVars] :: RW -> [Map Name Type]
-- | Selector constraints that have been solved (ref. iSolvedSelectorsLazy)
[iSolvedHas] :: RW -> Map Int HasGoalSln
[iNameSeeds] :: RW -> !NameSeeds
-- | Ordinary constraints
[iCts] :: RW -> !Goals
-- | Tuple/record projection constraints. The Int is the "name" of
-- the constraint, used so that we can name its solution properly.
[iHasCts] :: RW -> ![HasGoal]
-- | Nested scopes we are currently checking, most nested first.
[iScope] :: RW -> ![ModuleG ScopeName]
-- | Types of variables that we know about. We don't worry about scoping
-- here because we assume the bindings all have different names.
[iBindTypes] :: RW -> !Map Name Schema
[iSupply] :: RW -> !Supply
-- | Read-only component of the monad.
data RO
RO :: Range -> Map Name VarType -> [TParam] -> ModuleG ScopeName -> Map Int HasGoalSln -> Bool -> Bool -> Solver -> !PrimMap -> !IORef Int -> RO
-- | Source code being analysed
[iRange] :: RO -> Range
-- | Type of variable that are in scope These are only parameters vars that
-- are in recursive component we are checking at the moment. If a var is
-- not there, keep looking in the iScope
[iVars] :: RO -> Map Name VarType
-- | Type variable that are in scope
[iTVars] :: RO -> [TParam]
-- | These are things we know about, but are not part of the modules we are
-- currently constructing. XXX: this sould probably be an interface
[iExtScope] :: RO -> ModuleG ScopeName
-- | NOTE: This field is lazy in an important way! It is the final version
-- of iSolvedHas in RW, and the two are tied together
-- through recursion. The field is here so that we can look thing up
-- before they are defined, which is OK because we don't need to know the
-- results until everything is done.
[iSolvedHasLazy] :: RO -> Map Int HasGoalSln
-- | When this flag is set to true, bindings that lack signatures in
-- where-blocks will never be generalized. Bindings with type signatures,
-- and all bindings at top level are unaffected.
[iMonoBinds] :: RO -> Bool
-- | When this flag is true, retain source location information in
-- typechecked terms
[iCallStacks] :: RO -> Bool
[iSolver] :: RO -> Solver
[iPrimNames] :: RO -> !PrimMap
[iSolveCounter] :: RO -> !IORef Int
data ScopeName
ExternalScope :: ScopeName
LocalScope :: ScopeName
SubModule :: Name -> ScopeName
MTopModule :: ModName -> ScopeName
newtype InferM a
IM :: ReaderT RO (StateT RW IO) a -> InferM a
[unIM] :: InferM a -> ReaderT RO (StateT RW IO) a
-- | The results of type inference.
data InferOutput a
-- | We found some errors
InferFailed :: NameMap -> [(Range, Warning)] -> [(Range, Error)] -> InferOutput a
-- | Type inference was successful.
InferOK :: NameMap -> [(Range, Warning)] -> NameSeeds -> Supply -> a -> InferOutput a
-- | This is used for generating various names.
data NameSeeds
NameSeeds :: !Int -> !Int -> NameSeeds
[seedTVar] :: NameSeeds -> !Int
[seedGoal] :: NameSeeds -> !Int
-- | Information needed for type inference.
data InferInput
InferInput :: Range -> Map Name Schema -> Map Name TySyn -> Map Name Newtype -> Map Name AbstractType -> !Map Name ModTParam -> ![Located Prop] -> !Map Name ModVParam -> NameSeeds -> Bool -> Bool -> [FilePath] -> !PrimMap -> !Supply -> Solver -> InferInput
-- | Location of program source
[inpRange] :: InferInput -> Range
-- | Variables that are in scope
[inpVars] :: InferInput -> Map Name Schema
-- | Type synonyms that are in scope
[inpTSyns] :: InferInput -> Map Name TySyn
-- | Newtypes in scope
[inpNewtypes] :: InferInput -> Map Name Newtype
-- | Abstract types in scope
[inpAbstractTypes] :: InferInput -> Map Name AbstractType
-- | Type parameters
[inpParamTypes] :: InferInput -> !Map Name ModTParam
-- | Constraints on parameters
[inpParamConstraints] :: InferInput -> ![Located Prop]
-- | Value parameters
[inpParamFuns] :: InferInput -> !Map Name ModVParam
-- | Private state of type-checker
[inpNameSeeds] :: InferInput -> NameSeeds
-- | Should local bindings without signatures be monomorphized?
[inpMonoBinds] :: InferInput -> Bool
-- | Are we tracking call stacks?
[inpCallStacks] :: InferInput -> Bool
-- | Where to look for Cryptol theory file.
[inpSearchPath] :: InferInput -> [FilePath]
-- | This is used when the type-checker needs to refer to a predefined
-- identifier (e.g., number).
[inpPrimNames] :: InferInput -> !PrimMap
-- | The supply for fresh name generation
[inpSupply] :: InferInput -> !Supply
-- | Solver connection for typechecking
[inpSolver] :: InferInput -> Solver
-- | The initial seeds, used when checking a fresh program. XXX: why does
-- this start at 10?
nameSeeds :: NameSeeds
bumpCounter :: InferM ()
runInferM :: TVars a => InferInput -> InferM a -> IO (InferOutput a)
io :: IO a -> InferM a
-- | The monadic computation is about the given range of source code. This
-- is useful for error reporting.
inRange :: Range -> InferM a -> InferM a
inRangeMb :: Maybe Range -> InferM a -> InferM a
-- | This is the current range that we are working on.
curRange :: InferM Range
-- | Report an error.
recordError :: Error -> InferM ()
-- | Report an error.
recordErrorLoc :: Maybe Range -> Error -> InferM ()
recordWarning :: Warning -> InferM ()
getSolver :: InferM Solver
-- | Retrieve the mapping between identifiers and declarations in the
-- prelude.
getPrimMap :: InferM PrimMap
newGoal :: ConstraintSource -> Prop -> InferM Goal
-- | Record some constraints that need to be solved. The string explains
-- where the constraints came from.
newGoals :: ConstraintSource -> [Prop] -> InferM ()
-- | The constraints are removed, and returned to the caller. The
-- substitution IS applied to them.
getGoals :: InferM [Goal]
-- | Add a bunch of goals that need solving.
addGoals :: [Goal] -> InferM ()
-- | Collect the goals emitted by the given sub-computation. Does not emit
-- any new goals.
collectGoals :: InferM a -> InferM (a, [Goal])
simpGoal :: Goal -> InferM [Goal]
simpGoals :: [Goal] -> InferM [Goal]
-- | Record a constraint that when we select from the first type, we should
-- get a value of the second type. The returned function should be used
-- to wrap the expression from which we are selecting (i.e., the record
-- or tuple). Plese note that the resulting expression should not be
-- forced before the constraint is solved.
newHasGoal :: Selector -> Type -> Type -> InferM HasGoalSln
-- | Add a previously generate has constrained
addHasGoal :: HasGoal -> InferM ()
-- | Get the Has constraints. Each of this should either be
-- solved, or added back using addHasGoal.
getHasGoals :: InferM [HasGoal]
-- | Specify the solution (Expr -> Expr) for the given
-- constraint (Int).
solveHasGoal :: Int -> HasGoalSln -> InferM ()
-- | Generate a fresh variable name to be used in a local binding.
newParamName :: Namespace -> Ident -> InferM Name
newName :: (NameSeeds -> (a, NameSeeds)) -> InferM a
-- | Generate a new name for a goal.
newGoalName :: InferM Int
-- | Generate a new free type variable.
newTVar :: TypeSource -> Kind -> InferM TVar
-- | Generate a new free type variable that depends on these additional
-- type parameters.
newTVar' :: TypeSource -> Set TParam -> Kind -> InferM TVar
-- | Check that the given "flavor" of parameter is allowed to have the
-- given type, and raise an error if not
checkParamKind :: TParam -> TPFlavor -> Kind -> InferM ()
-- | Generate a new free type variable.
newTParam :: TParam Name -> TPFlavor -> Kind -> InferM TParam
-- | Generate an unknown type. The doc is a note about what is this type
-- about.
newType :: TypeSource -> Kind -> InferM Type
-- | Record that the two types should be syntactically equal.
unify :: TypeWithSource -> Type -> InferM [Prop]
-- | Apply the accumulated substitution to something with free type
-- variables.
applySubst :: TVars t => t -> InferM t
applySubstPreds :: [Prop] -> InferM [Prop]
applySubstGoals :: [Goal] -> InferM [Goal]
-- | Get the substitution that we have accumulated so far.
getSubst :: InferM Subst
-- | Add to the accumulated substitution, checking that the datatype
-- invariant for Subst is maintained.
extendSubst :: Subst -> InferM ()
-- | Variables that are either mentioned in the environment or in a
-- selector constraint.
varsWithAsmps :: InferM (Set TVar)
-- | Lookup the type of a variable.
lookupVar :: Name -> InferM VarType
-- | Lookup a type variable. Return Nothing if there is no such
-- variable in scope, in which case we must be dealing with a type
-- constant.
lookupTParam :: Name -> InferM (Maybe TParam)
-- | Lookup the definition of a type synonym.
lookupTSyn :: Name -> InferM (Maybe TySyn)
-- | Lookup the definition of a newtype
lookupNewtype :: Name -> InferM (Maybe Newtype)
lookupAbstractType :: Name -> InferM (Maybe AbstractType)
-- | Lookup the kind of a parameter type
lookupParamType :: Name -> InferM (Maybe ModTParam)
-- | Lookup the schema for a parameter function.
lookupParamFun :: Name -> InferM (Maybe ModVParam)
-- | Check if we already have a name for this existential type variable
-- and, if so, return the definition. If not, try to create a new
-- definition, if this is allowed. If not, returns nothing.
existVar :: Name -> Kind -> InferM Type
-- | Returns the type synonyms that are currently in scope.
getTSyns :: InferM (Map Name TySyn)
-- | Returns the newtype declarations that are in scope.
getNewtypes :: InferM (Map Name Newtype)
-- | Returns the abstract type declarations that are in scope.
getAbstractTypes :: InferM (Map Name AbstractType)
-- | Returns the parameter functions declarations
getParamFuns :: InferM (Map Name ModVParam)
-- | Returns the abstract function declarations
getParamTypes :: InferM (Map Name ModTParam)
-- | Constraints on the module's parameters.
getParamConstraints :: InferM [Located Prop]
-- | Get the set of bound type variables that are in scope.
getTVars :: InferM (Set Name)
-- | Return the keys of the bound variables that are in scope.
getBoundInScope :: InferM (Set TParam)
-- | Retrieve the value of the `mono-binds` option.
getMonoBinds :: InferM Bool
getCallStacks :: InferM Bool
-- | We disallow shadowing between type synonyms and type variables because
-- it is confusing. As a bonus, in the implementation we don't need to
-- worry about where we lookup things (i.e., in the variable or type
-- synonym environment.
checkTShadowing :: String -> Name -> InferM ()
-- | The sub-computation is performed with the given type parameter in
-- scope.
withTParam :: TParam -> InferM a -> InferM a
withTParams :: [TParam] -> InferM a -> InferM a
-- | Execute the given computation in a new top scope. The sub-computation
-- would typically be validating a module.
newScope :: ScopeName -> InferM ()
newLocalScope :: InferM ()
newSubmoduleScope :: Name -> [Import] -> ExportSpec Name -> InferM ()
newModuleScope :: ModName -> [Import] -> ExportSpec Name -> InferM ()
-- | Update the current scope (first in the list). Assumes there is one.
updScope :: (ModuleG ScopeName -> ModuleG ScopeName) -> InferM ()
endLocalScope :: InferM ([DeclGroup], Map Name TySyn)
endSubmodule :: InferM ()
endModule :: InferM Module
endModuleInstance :: InferM ()
-- | Get an environment combining all nested scopes.
getScope :: Semigroup a => (ModuleG ScopeName -> a) -> InferM a
addDecls :: DeclGroup -> InferM ()
-- | The sub-computation is performed with the given type-synonym in scope.
addTySyn :: TySyn -> InferM ()
addNewtype :: Newtype -> InferM ()
addPrimType :: AbstractType -> InferM ()
addParamType :: ModTParam -> InferM ()
-- | The sub-computation is performed with the given abstract function in
-- scope.
addParamFun :: ModVParam -> InferM ()
-- | Add some assumptions for an entire module
addParameterConstraints :: [Located Prop] -> InferM ()
-- | Perform the given computation in a new scope (i.e., the subcomputation
-- may use existential type variables). This is a different kind of scope
-- from the nested modules one.
inNewScope :: InferM a -> InferM a
-- | The sub-computation is performed with the given variable in scope.
withVarType :: Name -> VarType -> InferM a -> InferM a
withVarTypes :: [(Name, VarType)] -> InferM a -> InferM a
withVar :: Name -> Schema -> InferM a -> InferM a
-- | The sub-computation is performed with the given variables in scope.
withMonoType :: (Name, Located Type) -> InferM a -> InferM a
-- | The sub-computation is performed with the given variables in scope.
withMonoTypes :: Map Name (Located Type) -> InferM a -> InferM a
-- | The arguments to this function are as follows:
--
-- (type param. name, kind signature (opt.), type parameter)
--
-- The type parameter is just a thunk that we should not force. The
-- reason is that the parameter depends on the kind that we are in the
-- process of computing.
--
-- As a result we return the value of the sub-computation and the
-- computed kinds of the type parameters.
runKindM :: AllowWildCards -> [(Name, Maybe Kind, TParam)] -> KindM a -> InferM (a, Map Name Kind, [(ConstraintSource, [Prop])])
-- | Check if a name refers to a type variable.
kLookupTyVar :: Name -> KindM (Maybe LkpTyVar)
-- | Are type wild-cards OK in this context?
kWildOK :: KindM AllowWildCards
-- | Reports an error.
kRecordError :: Error -> KindM ()
kRecordWarning :: Warning -> KindM ()
kIO :: IO a -> KindM a
-- | Generate a fresh unification variable of the given kind. NOTE: We do
-- not simplify these, because we end up with bottom. See hs XXX:
-- Perhaps we can avoid the recursion?
kNewType :: TypeSource -> Kind -> KindM Type
-- | Lookup the definition of a type synonym.
kLookupTSyn :: Name -> KindM (Maybe TySyn)
-- | Lookup the definition of a newtype.
kLookupNewtype :: Name -> KindM (Maybe Newtype)
kLookupParamType :: Name -> KindM (Maybe ModTParam)
kLookupAbstractType :: Name -> KindM (Maybe AbstractType)
kExistTVar :: Name -> Kind -> KindM Type
-- | Replace the given bound variables with concrete types.
kInstantiateT :: Type -> [(TParam, Type)] -> KindM Type
-- | Record the kind for a local type variable. This assumes that we
-- already checked that there was no other valid kind for the variable
-- (if there was one, it gets over-written).
kSetKind :: Name -> Kind -> KindM ()
-- | The sub-computation is about the given range of the source code.
kInRange :: Range -> KindM a -> KindM a
kNewGoals :: ConstraintSource -> [Prop] -> KindM ()
kInInferM :: InferM a -> KindM a
instance Control.DeepSeq.NFData Cryptol.TypeCheck.Monad.NameSeeds
instance GHC.Generics.Generic Cryptol.TypeCheck.Monad.NameSeeds
instance GHC.Show.Show Cryptol.TypeCheck.Monad.NameSeeds
instance GHC.Show.Show a => GHC.Show.Show (Cryptol.TypeCheck.Monad.InferOutput a)
instance GHC.Base.Functor Cryptol.TypeCheck.Monad.KindM
instance GHC.Base.Applicative Cryptol.TypeCheck.Monad.KindM
instance GHC.Base.Monad Cryptol.TypeCheck.Monad.KindM
instance Control.Monad.Fail.MonadFail Cryptol.TypeCheck.Monad.KindM
instance GHC.Base.Functor Cryptol.TypeCheck.Monad.InferM
instance GHC.Base.Applicative Cryptol.TypeCheck.Monad.InferM
instance GHC.Base.Monad Cryptol.TypeCheck.Monad.InferM
instance Control.Monad.Fail.MonadFail Cryptol.TypeCheck.Monad.InferM
instance Control.Monad.Fix.MonadFix Cryptol.TypeCheck.Monad.InferM
instance Cryptol.ModuleSystem.Name.FreshM Cryptol.TypeCheck.Monad.InferM
module Cryptol.TypeCheck.Solver.Selector
-- | Solve has-constraints.
tryHasGoal :: HasGoal -> InferM (Bool, Bool)
module Cryptol.TypeCheck.Sanity
tcExpr :: InferInput -> Expr -> Either (Range, Error) (Schema, [ProofObligation])
tcDecls :: InferInput -> [DeclGroup] -> Either (Range, Error) [ProofObligation]
tcModule :: InferInput -> Module -> Either (Range, Error) [ProofObligation]
type ProofObligation = Schema
data Error
-- | expected, actual
TypeMismatch :: String -> Schema -> Schema -> Error
-- | expected a mono type, got this
ExpectedMono :: Schema -> Error
TupleSelectorOutOfRange :: Int -> Int -> Error
MissingField :: Ident -> [Ident] -> Error
UnexpectedTupleShape :: Int -> Int -> Error
UnexpectedRecordShape :: [Ident] -> [Ident] -> Error
UnexpectedSequenceShape :: Int -> Type -> Error
BadSelector :: Selector -> Type -> Error
BadInstantiation :: Error
Captured :: TVar -> Error
BadProofNoAbs :: Error
BadProofTyVars :: [TParam] -> Error
KindMismatch :: Kind -> Kind -> Error
NotEnoughArgumentsInKind :: Kind -> Error
BadApplication :: Type -> Type -> Error
FreeTypeVariable :: TVar -> Error
BadTypeApplication :: Kind -> [Kind] -> Error
RepeatedVariableInForall :: TParam -> Error
BadMatch :: Type -> Error
EmptyArm :: Error
UndefinedTypeVaraible :: TVar -> Error
UndefinedVariable :: Name -> Error
same :: Same a => a -> a -> Bool
instance GHC.Show.Show Cryptol.TypeCheck.Sanity.Error
instance GHC.Base.Functor Cryptol.TypeCheck.Sanity.TcM
instance GHC.Base.Applicative Cryptol.TypeCheck.Sanity.TcM
instance GHC.Base.Monad Cryptol.TypeCheck.Sanity.TcM
instance Cryptol.TypeCheck.Sanity.Same a => Cryptol.TypeCheck.Sanity.Same [a]
instance Cryptol.TypeCheck.Sanity.Same Cryptol.TypeCheck.Type.Type
instance Cryptol.TypeCheck.Sanity.Same Cryptol.TypeCheck.Type.Schema
instance Cryptol.TypeCheck.Sanity.Same Cryptol.TypeCheck.Type.TParam
module Cryptol.TypeCheck.Default
-- | We default constraints of the form Literal t a and
-- FLiteral m n r a.
--
-- For Literal t a we examine the context of constraints on the
-- type a to decide how to default. If Logic a is
-- required, we cannot do any defaulting. Otherwise, we default to either
-- Integer or Rational. In particular, if we need to
-- satisfy the Field a, constraint, we choose Rational
-- and otherwise we choose Integer.
--
-- For FLiteral t a we always default to Rational.
defaultLiterals :: [TVar] -> [Goal] -> ([TVar], Subst, [Warning])
flitDefaultCandidates :: Goals -> Map TVar (Maybe ((TVar, Type), Warning))
improveByDefaultingWithPure :: [TVar] -> [Goal] -> ([TVar], [Goal], Subst, [Error])
-- | Try to pick a reasonable instantiation for an expression with the
-- given type. This is useful when we do evaluation at the REPL. The
-- resulting types should satisfy the constraints of the schema. The
-- parameters should be all of numeric kind, and the props should als be
-- numeric
defaultReplExpr' :: Solver -> [TParam] -> [Prop] -> IO (Maybe [(TParam, Type)])
module Cryptol.TypeCheck.Solve
simplifyAllConstraints :: InferM ()
-- | Prove an implication, and return any improvements that we computed.
-- Records errors, if any of the goals couldn't be solved.
proveImplication :: Maybe Name -> [TParam] -> [Prop] -> [Goal] -> InferM Subst
-- | Try to clean-up any left-over constraints after we've checked
-- everything in a module. Typically these are either trivial things, or
-- constraints on the module's type parameters.
proveModuleTopLevel :: InferM ()
defaultAndSimplify :: [TVar] -> [Goal] -> ([TVar], [Goal], Subst, [Warning], [Error])
defaultReplExpr :: Solver -> Expr -> Schema -> IO (Maybe ([(TParam, Type)], Expr))
module Cryptol.TypeCheck.Kind
checkType :: Type Name -> Maybe Kind -> InferM Type
-- | Check a type signature. Returns validated schema, and any implicit
-- constraints that we inferred.
checkSchema :: AllowWildCards -> Schema Name -> InferM (Schema, [Goal])
-- | Check a newtype declaration. XXX: Do something with constraints.
checkNewtype :: Newtype Name -> Maybe Text -> InferM Newtype
checkPrimType :: PrimType Name -> Maybe Text -> InferM AbstractType
-- | Check a type-synonym declaration.
checkTySyn :: TySyn Name -> Maybe Text -> InferM TySyn
-- | Check a constraint-synonym declaration.
checkPropSyn :: PropSyn Name -> Maybe Text -> InferM TySyn
-- | Check a module parameter declarations. Nothing much to check, we just
-- translate from one syntax to another.
checkParameterType :: ParameterType Name -> Maybe Text -> InferM ModTParam
checkParameterConstraints :: [Located (Prop Name)] -> InferM [Located Prop]
module Cryptol.TypeCheck.Instantiate
instantiateWith :: Name -> Expr -> Schema -> [TypeArg] -> InferM (Expr, Type)
data TypeArg
TypeArg :: Maybe (Located Ident) -> MaybeCheckedType -> TypeArg
[tyArgName] :: TypeArg -> Maybe (Located Ident)
[tyArgType] :: TypeArg -> MaybeCheckedType
uncheckedTypeArg :: TypeInst Name -> TypeArg
data MaybeCheckedType
Checked :: Type -> MaybeCheckedType
Unchecked :: Type Name -> MaybeCheckedType
-- | Assumes that the NoPat pass has been run.
module Cryptol.TypeCheck.Infer
-- | Infer the type of an expression, and translate it to a fully
-- elaborated core term.
checkE :: Expr Name -> TypeWithSource -> InferM Expr
checkSigB :: Bind Name -> (Schema, [Goal]) -> InferM Decl
inferModule :: Module Name -> InferM Module
-- | inferBinds isTopLevel isRec binds performs inference for a
-- strongly-connected component of Binds. If any of the members of
-- the recursive group are already marked as monomorphic, then we don't
-- do generalization. If isTopLevel is true, any bindings
-- without type signatures will be generalized. If it is false, and the
-- mono-binds flag is enabled, no bindings without type signatures will
-- be generalized, but bindings with signatures will be unaffected.
inferBinds :: Bool -> Bool -> [Bind Name] -> InferM [Decl]
checkTopDecls :: [TopDecl Name] -> InferM ()
-- | This module implements a transformation, which tries to avoid
-- exponential slow down in some cases. What's the problem? Consider the
-- following (common) patterns:
--
--
-- fibs = [0,1] # [ x + y | x <- fibs, y <- drop`{1} fibs ]
--
--
-- The type of fibs is:
--
--
-- {a} (a >= 1, fin a) => [inf][a]
--
--
-- Here a is the number of bits to be used in the values
-- computed by fibs. When we evaluate fibs, a
-- becomes a parameter to fibs, which works except that now
-- fibs is a function, and we don't get any of the memoization
-- we might expect! What looked like an efficient implementation has all
-- of a sudden become exponential!
--
-- Note that this is only a problem for polymorphic values: if
-- fibs was already a function, it would not be that surprising
-- that it does not get cached.
--
-- So, to avoid this, we try to spot recursive polymorphic values, where
-- the recursive occurrences have the exact same type parameters as the
-- definition. For example, this is the case in fibs: each
-- recursive call to fibs is instantiated with exactly the same
-- type parameter (i.e., a). The rewrite we do is as follows:
--
--
-- fibs : {a} (a >= 1, fin a) => [inf][a]
-- fibs = \{a} (a >= 1, fin a) -> fibs'
-- where fibs' : [inf][a]
-- fibs' = [0,1] # [ x + y | x <- fibs', y <- drop`{1} fibs' ]
--
--
-- After the rewrite, the recursion is monomorphic (i.e., we are always
-- using the same type). As a result, fibs' is an ordinary
-- recursive value, where we get the benefit of caching.
--
-- The rewrite is a bit more complex, when there are multiple mutually
-- recursive functions. Here is an example:
--
--
-- zig : {a} (a >= 2, fin a) => [inf][a]
-- zig = [1] # zag
--
-- zag : {a} (a >= 2, fin a) => [inf][a]
-- zag = [2] # zig
--
--
-- This gets rewritten to:
--
--
-- newName : {a} (a >= 2, fin a) => ([inf][a], [inf][a])
-- newName = \{a} (a >= 2, fin a) -> (zig', zag')
-- where
-- zig' : [inf][a]
-- zig' = [1] # zag'
--
-- zag' : [inf][a]
-- zag' = [2] # zig'
--
-- zig : {a} (a >= 2, fin a) => [inf][a]
-- zig = \{a} (a >= 2, fin a) -> (newName a <> <> ).1
--
-- zag : {a} (a >= 2, fin a) => [inf][a]
-- zag = \{a} (a >= 2, fin a) -> (newName a <> <> ).2
--
--
-- NOTE: We are assuming that no capture would occur with binders. For
-- values, this is because we replaces things with freshly chosen
-- variables. For types, this should be because there should be no
-- shadowing in the types. XXX: Make sure that this really is the case
-- for types!!
module Cryptol.Transform.MonoValues
-- | Note that this assumes that this pass will be run only once for each
-- module, otherwise we will get name collisions.
rewModule :: Supply -> Module -> (Module, Supply)
instance Cryptol.TypeCheck.TypeMap.TrieMap Cryptol.Transform.MonoValues.RewMap' (Cryptol.ModuleSystem.Name.Name, [Cryptol.TypeCheck.Type.Type], GHC.Types.Int)
-- | Transformed a parametrized module into an ordinary module where
-- everything is parameterized by the module's parameters. Note that this
-- reuses the names from the original parameterized module.
module Cryptol.Transform.AddModParams
addModParams :: Module -> Either [Name] Module
instance Cryptol.Transform.AddModParams.Inst a => Cryptol.Transform.AddModParams.Inst [a]
instance Cryptol.Transform.AddModParams.Inst Cryptol.TypeCheck.AST.Expr
instance Cryptol.Transform.AddModParams.Inst Cryptol.TypeCheck.AST.Match
instance Cryptol.Transform.AddModParams.Inst Cryptol.TypeCheck.AST.DeclGroup
instance Cryptol.Transform.AddModParams.Inst Cryptol.TypeCheck.AST.Decl
instance Cryptol.Transform.AddModParams.Inst Cryptol.TypeCheck.AST.DeclDef
instance Cryptol.Transform.AddModParams.Inst Cryptol.TypeCheck.Type.Type
instance Cryptol.Transform.AddModParams.Inst Cryptol.TypeCheck.Type.TySyn
instance Cryptol.Transform.AddModParams.Inst Cryptol.TypeCheck.Type.Newtype
instance Cryptol.Transform.AddModParams.AddParams a => Cryptol.Transform.AddModParams.AddParams [a]
instance Cryptol.Transform.AddModParams.AddParams Cryptol.TypeCheck.Type.Schema
instance Cryptol.Transform.AddModParams.AddParams Cryptol.TypeCheck.Type.Type
instance Cryptol.Transform.AddModParams.AddParams Cryptol.TypeCheck.AST.Expr
instance Cryptol.Transform.AddModParams.AddParams Cryptol.TypeCheck.AST.DeclGroup
instance Cryptol.Transform.AddModParams.AddParams Cryptol.TypeCheck.AST.Decl
instance Cryptol.Transform.AddModParams.AddParams Cryptol.TypeCheck.Type.TySyn
instance Cryptol.Transform.AddModParams.AddParams Cryptol.TypeCheck.Type.Newtype
module Cryptol.ModuleSystem.NamingEnv
-- | The NamingEnv is used by the renamer to determine what
-- identifiers refer to.
newtype NamingEnv
NamingEnv :: Map Namespace (Map PName [Name]) -> NamingEnv
-- | All names mentioned in the environment
namingEnvNames :: NamingEnv -> Set Name
-- | Get the names in a given namespace
namespaceMap :: Namespace -> NamingEnv -> Map PName [Name]
-- | Resolve a name in the given namespace.
lookupNS :: Namespace -> PName -> NamingEnv -> [Name]
-- | Return a list of value-level names to which this parsed name may
-- refer.
lookupValNames :: PName -> NamingEnv -> [Name]
-- | Return a list of type-level names to which this parsed name may refer.
lookupTypeNames :: PName -> NamingEnv -> [Name]
-- | Singleton renaming environment for the given namespace.
singletonNS :: Namespace -> PName -> Name -> NamingEnv
-- | Singleton expression renaming environment.
singletonE :: PName -> Name -> NamingEnv
-- | Singleton type renaming environment.
singletonT :: PName -> Name -> NamingEnv
namingEnvRename :: (Name -> Name) -> NamingEnv -> NamingEnv
-- | Merge two name maps, collapsing cases where the entries are the same,
-- and producing conflicts otherwise.
merge :: [Name] -> [Name] -> [Name]
-- | Generate a mapping from PrimIdent to Name for a given
-- naming environment.
toPrimMap :: NamingEnv -> PrimMap
-- | Generate a display format based on a naming environment.
toNameDisp :: NamingEnv -> NameDisp
-- | Produce sets of visible names for types and declarations.
--
-- NOTE: if entries in the NamingEnv would have produced a name clash,
-- they will be omitted from the resulting sets.
visibleNames :: NamingEnv -> Map Namespace (Set Name)
-- | Qualify all symbols in a NamingEnv with the given prefix.
qualify :: ModName -> NamingEnv -> NamingEnv
filterNames :: (PName -> Bool) -> NamingEnv -> NamingEnv
-- | Like mappend, but when merging, prefer values on the lhs.
shadowing :: NamingEnv -> NamingEnv -> NamingEnv
travNamingEnv :: Applicative f => (Name -> f Name) -> NamingEnv -> f NamingEnv
-- | Do somethign in context. If Nothing than we are working with a
-- local declaration. Otherwise we are at the top-level of the given
-- module.
data InModule a
InModule :: Maybe ModPath -> a -> InModule a
newTop :: FreshM m => Namespace -> ModPath -> PName -> Maybe Fixity -> Range -> m Name
newLocal :: FreshM m => Namespace -> PName -> Range -> m Name
newtype BuildNamingEnv
BuildNamingEnv :: SupplyT Id NamingEnv -> BuildNamingEnv
[runBuild] :: BuildNamingEnv -> SupplyT Id NamingEnv
buildNamingEnv :: BuildNamingEnv -> Supply -> (NamingEnv, Supply)
-- | Generate a NamingEnv using an explicit supply.
defsOf :: BindsNames a => a -> Supply -> (NamingEnv, Supply)
type NestedMods = Map Name NamingEnv
type CollectM = StateT NestedMods (SupplyT Id)
collectNestedModules :: NamingEnv -> Module PName -> Supply -> (NestedMods, Supply)
collectNestedModulesDecls :: NamingEnv -> ModName -> [TopDecl PName] -> Supply -> (NestedMods, Supply)
collectNestedModulesDs :: ModPath -> NamingEnv -> [TopDecl PName] -> CollectM ()
-- | Things that define exported names.
class BindsNames a
namingEnv :: BindsNames a => a -> BuildNamingEnv
-- | Adapt the things exported by something to the specific import/open.
interpImportEnv :: ImportG name -> NamingEnv -> NamingEnv
-- | Interpret an import in the context of an interface, to produce a name
-- environment for the renamer, and a NameDisp for
-- pretty-printing.
interpImportIface :: Import -> IfaceDecls -> NamingEnv
-- | Generate a naming environment from a declaration interface, where none
-- of the names are qualified.
unqualifiedEnv :: IfaceDecls -> NamingEnv
-- | Compute an unqualified naming environment, containing the various
-- module parameters.
modParamsNamingEnv :: IfaceParams -> NamingEnv
data ImportIface
ImportIface :: Import -> Iface -> ImportIface
moduleDefs :: ModPath -> ModuleG mname PName -> BuildNamingEnv
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.NamingEnv.NamingEnv
instance GHC.Generics.Generic Cryptol.ModuleSystem.NamingEnv.NamingEnv
instance GHC.Show.Show Cryptol.ModuleSystem.NamingEnv.NamingEnv
instance GHC.Show.Show a => GHC.Show.Show (Cryptol.ModuleSystem.NamingEnv.InModule a)
instance Data.Foldable.Foldable Cryptol.ModuleSystem.NamingEnv.InModule
instance Data.Traversable.Traversable Cryptol.ModuleSystem.NamingEnv.InModule
instance GHC.Base.Functor Cryptol.ModuleSystem.NamingEnv.InModule
instance Cryptol.ModuleSystem.NamingEnv.BindsNames Cryptol.ModuleSystem.NamingEnv.ImportIface
instance Cryptol.ModuleSystem.NamingEnv.BindsNames Cryptol.ModuleSystem.NamingEnv.NamingEnv
instance Cryptol.ModuleSystem.NamingEnv.BindsNames a => Cryptol.ModuleSystem.NamingEnv.BindsNames (GHC.Maybe.Maybe a)
instance Cryptol.ModuleSystem.NamingEnv.BindsNames a => Cryptol.ModuleSystem.NamingEnv.BindsNames [a]
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.Parser.AST.Schema Cryptol.Parser.Name.PName)
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.ModuleSystem.NamingEnv.InModule (Cryptol.Parser.AST.Bind Cryptol.Parser.Name.PName))
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.Parser.AST.TParam Cryptol.Parser.Name.PName)
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.Parser.AST.Module Cryptol.Parser.Name.PName)
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.ModuleSystem.NamingEnv.InModule (Cryptol.Parser.AST.TopDecl Cryptol.Parser.Name.PName))
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.ModuleSystem.NamingEnv.InModule (Cryptol.Parser.AST.NestedModule Cryptol.Parser.Name.PName))
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.ModuleSystem.NamingEnv.InModule (Cryptol.Parser.AST.PrimType Cryptol.Parser.Name.PName))
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.ModuleSystem.NamingEnv.InModule (Cryptol.Parser.AST.ParameterFun Cryptol.Parser.Name.PName))
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.ModuleSystem.NamingEnv.InModule (Cryptol.Parser.AST.ParameterType Cryptol.Parser.Name.PName))
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.ModuleSystem.NamingEnv.InModule (Cryptol.Parser.AST.Newtype Cryptol.Parser.Name.PName))
instance Cryptol.ModuleSystem.NamingEnv.BindsNames (Cryptol.ModuleSystem.NamingEnv.InModule (Cryptol.Parser.AST.Decl Cryptol.Parser.Name.PName))
instance GHC.Base.Semigroup Cryptol.ModuleSystem.NamingEnv.BuildNamingEnv
instance GHC.Base.Monoid Cryptol.ModuleSystem.NamingEnv.BuildNamingEnv
instance GHC.Base.Semigroup Cryptol.ModuleSystem.NamingEnv.NamingEnv
instance GHC.Base.Monoid Cryptol.ModuleSystem.NamingEnv.NamingEnv
instance Cryptol.Utils.PP.PP Cryptol.ModuleSystem.NamingEnv.NamingEnv
module Cryptol.ModuleSystem.Renamer.Monad
-- | Indicates if a name is in a binding poisition or a use site
data NameType
NameBind :: NameType
NameUse :: NameType
-- | Information needed to do some renaming.
data RenamerInfo
RenamerInfo :: Supply -> ModPath -> NamingEnv -> (ModName -> Iface) -> RenamerInfo
-- | Use to make new names
[renSupply] :: RenamerInfo -> Supply
-- | We are renaming things in here
[renContext] :: RenamerInfo -> ModPath
-- | This is what's in scope
[renEnv] :: RenamerInfo -> NamingEnv
[renIfaces] :: RenamerInfo -> ModName -> Iface
newtype RenameM a
RenameM :: ReaderT RO (StateT RW Lift) a -> RenameM a
[unRenameM] :: RenameM a -> ReaderT RO (StateT RW Lift) a
data RO
RO :: Range -> NamingEnv -> (ModName -> Iface) -> ModPath -> Map ModPath Name -> RO
[roLoc] :: RO -> Range
[roNames] :: RO -> NamingEnv
[roIfaces] :: RO -> ModName -> Iface
-- | Current module we are working on
[roCurMod] :: RO -> ModPath
[roNestedMods] :: RO -> Map ModPath Name
data RW
RW :: ![RenamerWarning] -> !Seq RenamerError -> !Supply -> !Map Name Int -> Set Name -> Map DepName (Set Name) -> !IfaceDecls -> RW
[rwWarnings] :: RW -> ![RenamerWarning]
[rwErrors] :: RW -> !Seq RenamerError
[rwSupply] :: RW -> !Supply
-- | How many times did we refer to each name. Used to generate warnings
-- for unused definitions.
[rwNameUseCount] :: RW -> !Map Name Int
-- | keeps track of names *used* by something. see depsOf
[rwCurrentDeps] :: RW -> Set Name
-- | keeps track of the dependencies for things. see depsOf
[rwDepGraph] :: RW -> Map DepName (Set Name)
-- | Info about imported things
[rwExternalDeps] :: RW -> !IfaceDecls
runRenamer :: RenamerInfo -> RenameM a -> (Either [RenamerError] (a, Supply), [RenamerWarning])
setCurMod :: ModPath -> RenameM a -> RenameM a
getCurMod :: RenameM ModPath
getNamingEnv :: RenameM NamingEnv
setNestedModule :: Map ModPath Name -> RenameM a -> RenameM a
nestedModuleOrig :: ModPath -> RenameM (Maybe Name)
-- | Record an error. XXX: use a better name
record :: RenamerError -> RenameM ()
collectIfaceDeps :: RenameM a -> RenameM (IfaceDecls, a)
-- | Rename something. All name uses in the sub-computation are assumed to
-- be dependenices of the thing.
depsOf :: DepName -> RenameM a -> RenameM a
-- | This is used when renaming a group of things. The result contains
-- dependencies between names defines and the group, and is intended to
-- be used to order the group members in dependency order.
depGroup :: RenameM a -> RenameM (a, Map DepName (Set Name))
-- | Get the source range for wahtever we are currently renaming.
curLoc :: RenameM Range
-- | Annotate something with the current range.
located :: a -> RenameM (Located a)
-- | Do the given computation using the source code range from loc
-- if any.
withLoc :: HasLoc loc => loc -> RenameM a -> RenameM a
-- | Shadow the current naming environment with some more names.
shadowNames :: BindsNames env => env -> RenameM a -> RenameM a
data EnvCheck
-- | Check for overlap and shadowing
CheckAll :: EnvCheck
-- | Only check for overlap
CheckOverlap :: EnvCheck
-- | Don't check the environment
CheckNone :: EnvCheck
-- | Shadow the current naming environment with some more names.
shadowNames' :: BindsNames env => EnvCheck -> env -> RenameM a -> RenameM a
-- | Generate warnings when the left environment shadows things defined in
-- the right. Additionally, generate errors when two names overlap in the
-- left environment.
checkEnv :: EnvCheck -> NamingEnv -> NamingEnv -> RW -> (NamingEnv, RW)
-- | Check the RHS of a single name rewrite for conflicting sources.
containsOverlap :: [Name] -> Seq RenamerError
recordUse :: Name -> RenameM ()
-- | Mark something as a dependency. This is similar but different from
-- recordUse, in particular: * We only record use sites, not
-- bindings * We record all namespaces, not just types * We only keep
-- track of actual uses mentioned in the code. Otoh, recordUse
-- also considers exported entities to be used. * If we depend on a name
-- from a sibling submodule we add a dependency on the module in our
-- common ancestor. Examples: - A::B::x depends on
-- A::B::C::D::y, x depends on A::B::C -
-- A::B::x depends on A::P::Q::y, x
-- depends on A::P@
addDep :: Name -> RenameM ()
warnUnused :: ModPath -> NamingEnv -> RW -> [RenamerWarning]
-- | Get the exported declarations in a module
lookupImport :: Import -> RenameM IfaceDecls
instance GHC.Show.Show Cryptol.ModuleSystem.Renamer.Monad.EnvCheck
instance GHC.Classes.Eq Cryptol.ModuleSystem.Renamer.Monad.EnvCheck
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Cryptol.ModuleSystem.Renamer.Monad.RenameM a)
instance (GHC.Base.Semigroup a, GHC.Base.Monoid a) => GHC.Base.Monoid (Cryptol.ModuleSystem.Renamer.Monad.RenameM a)
instance GHC.Base.Functor Cryptol.ModuleSystem.Renamer.Monad.RenameM
instance GHC.Base.Applicative Cryptol.ModuleSystem.Renamer.Monad.RenameM
instance GHC.Base.Monad Cryptol.ModuleSystem.Renamer.Monad.RenameM
instance Cryptol.ModuleSystem.Name.FreshM Cryptol.ModuleSystem.Renamer.Monad.RenameM
-- | Assumes that local names do not shadow top level names.
module Cryptol.ModuleSystem.InstantiateModule
-- | Convert a module instantiation into a partial module. The resulting
-- module is incomplete because it is missing the definitions from the
-- instantiation.
instantiateModule :: FreshM m => Module -> ModName -> Map TParam Type -> Map Name Expr -> m (Name -> Name, [Located Prop], Module)
instance GHC.Show.Show Cryptol.ModuleSystem.InstantiateModule.Env
instance Cryptol.ModuleSystem.InstantiateModule.Inst a => Cryptol.ModuleSystem.InstantiateModule.Inst [a]
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.AST.Expr
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.AST.DeclGroup
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.AST.DeclDef
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.AST.Decl
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.AST.Match
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.Type.Schema
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.Type.Type
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.TCon.TCon
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.TCon.TC
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.TCon.UserTC
instance Cryptol.ModuleSystem.InstantiateModule.Inst (Cryptol.ModuleSystem.Exports.ExportSpec Cryptol.ModuleSystem.Name.Name)
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.Type.TySyn
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.Type.Newtype
instance Cryptol.ModuleSystem.InstantiateModule.Inst Cryptol.TypeCheck.Type.AbstractType
instance Cryptol.ModuleSystem.InstantiateModule.Defines t => Cryptol.ModuleSystem.InstantiateModule.Defines [t]
instance Cryptol.ModuleSystem.InstantiateModule.Defines Cryptol.TypeCheck.AST.Decl
instance Cryptol.ModuleSystem.InstantiateModule.Defines Cryptol.TypeCheck.AST.DeclGroup
module Cryptol.TypeCheck.CheckModuleInstance
-- | Check that the instance provides what the functor needs.
checkModuleInstance :: Module -> Module -> InferM (Name -> Name, Module)
module Cryptol.TypeCheck
tcModule :: Module Name -> InferInput -> IO (InferOutput Module)
-- | Check a module instantiation, assuming that the functor has already
-- been checked. XXX: This will change
tcModuleInst :: IORef NamingEnv -> Module -> Module Name -> InferInput -> IO (InferOutput Module)
tcExpr :: Expr Name -> InferInput -> IO (InferOutput (Expr, Schema))
tcDecls :: [TopDecl Name] -> InferInput -> IO (InferOutput ([DeclGroup], Map Name TySyn))
-- | Information needed for type inference.
data InferInput
InferInput :: Range -> Map Name Schema -> Map Name TySyn -> Map Name Newtype -> Map Name AbstractType -> !Map Name ModTParam -> ![Located Prop] -> !Map Name ModVParam -> NameSeeds -> Bool -> Bool -> [FilePath] -> !PrimMap -> !Supply -> Solver -> InferInput
-- | Location of program source
[inpRange] :: InferInput -> Range
-- | Variables that are in scope
[inpVars] :: InferInput -> Map Name Schema
-- | Type synonyms that are in scope
[inpTSyns] :: InferInput -> Map Name TySyn
-- | Newtypes in scope
[inpNewtypes] :: InferInput -> Map Name Newtype
-- | Abstract types in scope
[inpAbstractTypes] :: InferInput -> Map Name AbstractType
-- | Type parameters
[inpParamTypes] :: InferInput -> !Map Name ModTParam
-- | Constraints on parameters
[inpParamConstraints] :: InferInput -> ![Located Prop]
-- | Value parameters
[inpParamFuns] :: InferInput -> !Map Name ModVParam
-- | Private state of type-checker
[inpNameSeeds] :: InferInput -> NameSeeds
-- | Should local bindings without signatures be monomorphized?
[inpMonoBinds] :: InferInput -> Bool
-- | Are we tracking call stacks?
[inpCallStacks] :: InferInput -> Bool
-- | Where to look for Cryptol theory file.
[inpSearchPath] :: InferInput -> [FilePath]
-- | This is used when the type-checker needs to refer to a predefined
-- identifier (e.g., number).
[inpPrimNames] :: InferInput -> !PrimMap
-- | The supply for fresh name generation
[inpSupply] :: InferInput -> !Supply
-- | Solver connection for typechecking
[inpSolver] :: InferInput -> Solver
-- | The results of type inference.
data InferOutput a
-- | We found some errors
InferFailed :: NameMap -> [(Range, Warning)] -> [(Range, Error)] -> InferOutput a
-- | Type inference was successful.
InferOK :: NameMap -> [(Range, Warning)] -> NameSeeds -> Supply -> a -> InferOutput a
data SolverConfig
SolverConfig :: FilePath -> [String] -> Int -> [FilePath] -> SolverConfig
-- | The SMT solver to invoke
[solverPath] :: SolverConfig -> FilePath
-- | Additional arguments to pass to the solver
[solverArgs] :: SolverConfig -> [String]
-- | How verbose to be when type-checking
[solverVerbose] :: SolverConfig -> Int
-- | Look for the solver prelude in these locations.
[solverPreludePath] :: SolverConfig -> [FilePath]
-- | A default configuration for using Z3, where the solver prelude is
-- expected to be found in the given search path.
defaultSolverConfig :: [FilePath] -> SolverConfig
-- | This is used for generating various names.
data NameSeeds
-- | The initial seeds, used when checking a fresh program. XXX: why does
-- this start at 10?
nameSeeds :: NameSeeds
-- | Various errors that might happen during type checking/inference
data Error
-- | Expected kind, inferred kind
KindMismatch :: Maybe TypeSource -> Kind -> Kind -> Error
-- | Number of extra parameters, kind of result (which should not be of the
-- form _ -> _)
TooManyTypeParams :: Int -> Kind -> Error
-- | A type variable was applied to some arguments.
TyVarWithParams :: Error
-- | Type-synonym, number of extra params
TooManyTySynParams :: Name -> Int -> Error
-- | Who is missing params, number of missing params
TooFewTyParams :: Name -> Int -> Error
-- | The type synonym declarations are recursive
RecursiveTypeDecls :: [Name] -> Error
-- | Expected type, inferred type
TypeMismatch :: TypeSource -> Path -> Type -> Type -> Error
-- | Unification results in a recursive type
RecursiveType :: TypeSource -> Path -> Type -> Type -> Error
-- | A constraint that we could not solve, usually because there are some
-- left-over variables that we could not infer.
UnsolvedGoals :: [Goal] -> Error
-- | A constraint that we could not solve and we know it is impossible to
-- do it.
UnsolvableGoals :: [Goal] -> Error
-- | A constraint (with context) that we could not solve
UnsolvedDelayedCt :: DelayedCt -> Error
-- | Type wild cards are not allowed in this context (e.g., definitions of
-- type synonyms).
UnexpectedTypeWildCard :: Error
-- | Unification variable depends on quantified variables that are not in
-- scope.
TypeVariableEscaped :: TypeSource -> Path -> Type -> [TParam] -> Error
-- | Quantified type variables (of kind *) need to match the given type, so
-- it does not work for all types.
NotForAll :: TypeSource -> Path -> TVar -> Type -> Error
-- | Too many positional type arguments, in an explicit type instantiation
TooManyPositionalTypeParams :: Error
-- | Kind other than * or # given to parameter of type
-- synonym, newtype, function signature, etc.
BadParameterKind :: TParam -> Kind -> Error
CannotMixPositionalAndNamedTypeParams :: Error
UndefinedTypeParameter :: Located Ident -> Error
RepeatedTypeParameter :: Ident -> [Range] -> Error
-- | Could not determine the value of a numeric type variable, but we know
-- it must be at least as large as the given type (or unconstrained, if
-- Nothing).
AmbiguousSize :: TVarInfo -> Maybe Type -> Error
-- | Bare expression of the form `{_}
BareTypeApp :: Error
UndefinedExistVar :: Name -> Error
TypeShadowing :: String -> Name -> String -> Error
MissingModTParam :: Located Ident -> Error
MissingModVParam :: Located Ident -> Error
-- | This is for errors that don't fit other cateogories. We should not use
-- it much, and is generally to be used for transient errors, which are
-- due to incomplete implementation.
TemporaryError :: Doc -> Error
data Warning
DefaultingKind :: TParam Name -> Kind -> Warning
DefaultingWildType :: Kind -> Warning
DefaultingTo :: !TVarInfo -> Type -> Warning
ppWarning :: (Range, Warning) -> Doc
ppError :: (Range, Error) -> Doc
-- | This packages together a type with some names to be used to display
-- the variables. It is used for pretty printing types.
data WithNames a
WithNames :: a -> NameMap -> WithNames a
type NameMap = IntMap String
ppNamedWarning :: NameMap -> (Range, Warning) -> Doc
ppNamedError :: NameMap -> (Range, Error) -> Doc
module Cryptol.Backend.Monad
-- | The monad for Cryptol evaluation. A computation is either "ready",
-- which means it represents only trivial computation, or is an "eval"
-- action which must be computed to get the answer, or it is a "thunk",
-- which represents a delayed, shared computation.
data Eval a
Ready :: !a -> Eval a
Eval :: !CallStack -> IO a -> Eval a
Thunk :: !TVar (ThunkState a) -> Eval a
-- | Execute the given evaluation action.
runEval :: CallStack -> Eval a -> IO a
-- | Lift an IO computation into the Eval monad.
io :: IO a -> Eval a
-- | Delay the given evaluation computation, returning a thunk which will
-- run the computation when forced. Run the retry computation
-- instead if the resulting thunk is forced during its own evaluation.
delayFill :: Eval a -> Maybe (Eval a) -> String -> Eval (Eval a)
-- | A computation that returns an already-evaluated value.
ready :: a -> Eval a
-- | Produce a thunk value which can be filled with its associated
-- computation after the fact. A preallocated thunk is returned, along
-- with an operation to fill the thunk with the associated computation.
-- This is used to implement recursive declaration groups.
blackhole :: String -> Eval (Eval a, Eval a -> Eval ())
-- | Begin executing the given operation in a separate thread, returning a
-- thunk which will await the completion of the computation when forced.
evalSpark :: Eval a -> Eval (Eval a)
-- | Test if a value is "ready", which means that it requires no
-- computation to return.
maybeReady :: Eval a -> Eval (Maybe a)
-- | The type of dynamic call stacks for the interpreter. New frames are
-- pushed onto the right side of the sequence.
data CallStack
-- | Get the current call stack
getCallStack :: Eval CallStack
-- | Execute the action with the given call stack
withCallStack :: CallStack -> Eval a -> Eval a
-- | Run the given action with a modify call stack
modifyCallStack :: (CallStack -> CallStack) -> Eval a -> Eval a
-- | Combine the call stack of a function value with the call stack of the
-- current calling context. This algorithm is the same one GHC uses to
-- compute profiling calling contexts.
--
-- The algorithm is as follows.
--
-- ccs ++> ccsfn = ccs ++ dropCommonPrefix ccs ccsfn
--
-- where
--
-- dropCommonPrefix A B -- returns the suffix of B after removing any
-- prefix common -- to both A and B.
combineCallStacks :: CallStack -> CallStack -> CallStack
-- | Add a call frame to the top of a call stack
pushCallFrame :: Name -> Range -> CallStack -> CallStack
-- | Pretty print a call stack with each call frame on a separate line,
-- with most recent call frames at the top.
displayCallStack :: CallStack -> Doc
data Unsupported
-- | Operation cannot be supported in the symbolic simulator
UnsupportedSymbolicOp :: String -> Unsupported
-- | Data type describing errors that can occur during evaluation.
data EvalError
-- | Out-of-bounds index
InvalidIndex :: Maybe Integer -> EvalError
-- | Division or modulus by 0
DivideByZero :: EvalError
-- | Exponentiation by negative integer
NegativeExponent :: EvalError
-- | Logarithm of a negative integer
LogNegative :: EvalError
-- | Call to the Cryptol error primitive
UserError :: String -> EvalError
-- | Detectable nontermination
LoopError :: String -> EvalError
-- | Primitive with no implementation
NoPrim :: Name -> EvalError
-- | Invalid rounding mode
BadRoundingMode :: Integer -> EvalError
-- | Value outside the domain of a partial function.
BadValue :: String -> EvalError
data EvalErrorEx
EvalErrorEx :: CallStack -> EvalError -> EvalErrorEx
-- | Panic from an Eval context.
evalPanic :: HasCallStack => String -> [String] -> a
-- | For when we know that a word is too wide and will exceed gmp's limits
-- (though words approaching this size will probably cause the system to
-- crash anyway due to lack of memory).
wordTooWide :: Integer -> a
data WordTooWide
-- | Bitvector too large
WordTooWide :: Integer -> WordTooWide
instance GHC.Show.Show Cryptol.Backend.Monad.Unsupported
instance Cryptol.Utils.PP.PP Cryptol.Backend.Monad.WordTooWide
instance GHC.Show.Show Cryptol.Backend.Monad.WordTooWide
instance GHC.Exception.Type.Exception Cryptol.Backend.Monad.WordTooWide
instance Cryptol.Utils.PP.PP Cryptol.Backend.Monad.Unsupported
instance GHC.Exception.Type.Exception Cryptol.Backend.Monad.Unsupported
instance GHC.Base.Functor Cryptol.Backend.Monad.Eval
instance GHC.Base.Applicative Cryptol.Backend.Monad.Eval
instance GHC.Base.Monad Cryptol.Backend.Monad.Eval
instance Control.Monad.IO.Class.MonadIO Cryptol.Backend.Monad.Eval
instance Cryptol.Utils.PP.PP Cryptol.Backend.Monad.EvalErrorEx
instance GHC.Show.Show Cryptol.Backend.Monad.EvalErrorEx
instance GHC.Exception.Type.Exception Cryptol.Backend.Monad.EvalErrorEx
instance Cryptol.Utils.PP.PP Cryptol.Backend.Monad.EvalError
instance GHC.Show.Show Cryptol.Backend.Monad.EvalError
instance GHC.Base.Semigroup Cryptol.Backend.Monad.CallStack
instance GHC.Base.Monoid Cryptol.Backend.Monad.CallStack
module Cryptol.Backend.FloatHelpers
data BF
BF :: !Integer -> !Integer -> !BigFloat -> BF
[bfExpWidth] :: BF -> !Integer
[bfPrecWidth] :: BF -> !Integer
[bfValue] :: BF -> !BigFloat
-- | Make LibBF options for the given precision and rounding mode.
fpOpts :: Integer -> Integer -> RoundMode -> BFOpts
-- | Mapping from the rounding modes defined in the cry to the
-- rounding modes of LibBF.
fpRound :: Integer -> Either EvalError RoundMode
-- | Check that we didn't get an unexpected status.
fpCheckStatus :: (BigFloat, Status) -> BigFloat
-- | Pretty print a float
fpPP :: PPOpts -> BF -> Doc
-- | Make a literal
fpLit :: Integer -> Integer -> Rational -> BF
-- | Make a floating point number from a rational, using the given rounding
-- mode
floatFromRational :: Integer -> Integer -> RoundMode -> Rational -> BF
-- | Convert a floating point number to a rational, if possible.
floatToRational :: String -> BF -> Either EvalError Rational
-- | Convert a floating point number to an integer, if possible.
floatToInteger :: String -> RoundMode -> BF -> Either EvalError Integer
floatFromBits :: Integer -> Integer -> Integer -> BF
-- | Turn a float into raw bits. NaN is represented as a positive
-- "quiet" NaN (most significant bit in the significand is set,
-- the rest of it is 0)
floatToBits :: Integer -> Integer -> BigFloat -> Integer
module Cryptol.Backend
-- | This type class defines a collection of operations on bits, words and
-- integers that are necessary to define generic evaluator primitives
-- that operate on both concrete and symbolic values uniformly.
class MonadIO (SEval sym) => Backend sym where {
type family SBit sym :: Type;
type family SWord sym :: Type;
type family SInteger sym :: Type;
type family SFloat sym :: Type;
type family SEval sym :: Type -> Type;
}
-- | Check if an operation is "ready", which means its evaluation will be
-- trivial.
isReady :: Backend sym => sym -> SEval sym a -> SEval sym (Maybe a)
-- | Produce a thunk value which can be filled with its associated
-- computation after the fact. A preallocated thunk is returned, along
-- with an operation to fill the thunk with the associated computation.
-- This is used to implement recursive declaration groups.
sDeclareHole :: Backend sym => sym -> String -> SEval sym (SEval sym a, SEval sym a -> SEval sym ())
-- | Delay the given evaluation computation, returning a thunk which will
-- run the computation when forced. Run the retry computation
-- instead if the resulting thunk is forced during its own evaluation.
sDelayFill :: Backend sym => sym -> SEval sym a -> Maybe (SEval sym a) -> String -> SEval sym (SEval sym a)
-- | Begin evaluating the given computation eagerly in a separate thread
-- and return a thunk which will await the completion of the given
-- computation when forced.
sSpark :: Backend sym => sym -> SEval sym a -> SEval sym (SEval sym a)
-- | Push a call frame on to the current call stack while evaluating the
-- given action
sPushFrame :: Backend sym => sym -> Name -> Range -> SEval sym a -> SEval sym a
-- | Use the given call stack while evaluating the given action
sWithCallStack :: Backend sym => sym -> CallStack -> SEval sym a -> SEval sym a
-- | Apply the given function to the current call stack while evaluating
-- the given action
sModifyCallStack :: Backend sym => sym -> (CallStack -> CallStack) -> SEval sym a -> SEval sym a
-- | Retrieve the current evaluation call stack
sGetCallStack :: Backend sym => sym -> SEval sym CallStack
-- | Merge the two given computations according to the predicate.
mergeEval :: Backend sym => sym -> (SBit sym -> a -> a -> SEval sym a) -> SBit sym -> SEval sym a -> SEval sym a -> SEval sym a
-- | Assert that a condition must hold, and indicate what sort of error is
-- indicated if the condition fails.
assertSideCondition :: Backend sym => sym -> SBit sym -> EvalError -> SEval sym ()
-- | Indiciate that an error condition exists
raiseError :: Backend sym => sym -> EvalError -> SEval sym a
-- | Determine if this symbolic bit is a boolean literal
bitAsLit :: Backend sym => sym -> SBit sym -> Maybe Bool
-- | The number of bits in a word value.
wordLen :: Backend sym => sym -> SWord sym -> Integer
-- | Determine if this symbolic word is a literal. If so, return the bit
-- width and value.
wordAsLit :: Backend sym => sym -> SWord sym -> Maybe (Integer, Integer)
-- | Attempt to render a word value as an ASCII character. Return
-- Nothing if the character value is unknown (e.g., for symbolic
-- values).
wordAsChar :: Backend sym => sym -> SWord sym -> Maybe Char
-- | Determine if this symbolic integer is a literal
integerAsLit :: Backend sym => sym -> SInteger sym -> Maybe Integer
-- | Determine if this symbolic floating-point value is a literal
fpAsLit :: Backend sym => sym -> SFloat sym -> Maybe BF
-- | Construct a literal bit value from a boolean.
bitLit :: Backend sym => sym -> Bool -> SBit sym
-- | Construct a literal word value given a bit width and a value.
wordLit :: Backend sym => sym -> Integer -> Integer -> SEval sym (SWord sym)
-- | Construct a literal integer value from the given integer.
integerLit :: Backend sym => sym -> Integer -> SEval sym (SInteger sym)
-- | Construct a floating point value from the given rational.
fpLit :: Backend sym => sym -> Integer -> Integer -> Rational -> SEval sym (SFloat sym)
-- | Construct a floating point value from the given bit-precise
-- floating-point representation.
fpExactLit :: Backend sym => sym -> BF -> SEval sym (SFloat sym)
iteBit :: Backend sym => sym -> SBit sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
iteWord :: Backend sym => sym -> SBit sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
iteInteger :: Backend sym => sym -> SBit sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
iteFloat :: Backend sym => sym -> SBit sym -> SFloat sym -> SFloat sym -> SEval sym (SFloat sym)
bitEq :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
bitOr :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
bitAnd :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
bitXor :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
bitComplement :: Backend sym => sym -> SBit sym -> SEval sym (SBit sym)
-- | Extract the numbered bit from the word.
--
-- NOTE: this assumes that the sequence of bits is big-endian and finite,
-- so the bit numbered 0 is the most significant bit.
wordBit :: Backend sym => sym -> SWord sym -> Integer -> SEval sym (SBit sym)
-- | Update the numbered bit in the word.
--
-- NOTE: this assumes that the sequence of bits is big-endian and finite,
-- so the bit numbered 0 is the most significant bit.
wordUpdate :: Backend sym => sym -> SWord sym -> Integer -> SBit sym -> SEval sym (SWord sym)
-- | Construct a word value from a finite sequence of bits. NOTE: this
-- assumes that the sequence of bits is big-endian and finite, so the
-- first element of the list will be the most significant bit.
packWord :: Backend sym => sym -> [SBit sym] -> SEval sym (SWord sym)
-- | Deconstruct a packed word value in to a finite sequence of bits. NOTE:
-- this produces a list of bits that represent a big-endian word, so the
-- most significant bit is the first element of the list.
unpackWord :: Backend sym => sym -> SWord sym -> SEval sym [SBit sym]
-- | Construct a packed word of the specified width from an integer value.
wordFromInt :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SWord sym)
-- | Concatenate the two given word values. NOTE: the first argument
-- represents the more-significant bits
joinWord :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Take the most-significant bits, and return those bits and the
-- remainder. The first element of the pair is the most significant bits.
-- The two integer sizes must sum to the length of the given word value.
splitWord :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SEval sym (SWord sym, SWord sym)
-- | Extract a subsequence of bits from a packed word value. The first
-- integer argument is the number of bits in the resulting word. The
-- second integer argument is the number of less-significant digits to
-- discard. Stated another way, the operation extractWord n i w
-- is equivalent to first shifting w right by i bits,
-- and then truncating to n bits.
extractWord :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SEval sym (SWord sym)
-- | Bitwise OR
wordOr :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Bitwise AND
wordAnd :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Bitwise XOR
wordXor :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Bitwise complement
wordComplement :: Backend sym => sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement addition of packed words. The arguments must have equal
-- bit width, and the result is of the same width. Overflow is silently
-- discarded.
wordPlus :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement subtraction of packed words. The arguments must have
-- equal bit width, and the result is of the same width. Overflow is
-- silently discarded.
wordMinus :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement multiplication of packed words. The arguments must have
-- equal bit width, and the result is of the same width. The high bits of
-- the multiplication are silently discarded.
wordMult :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement unsigned division of packed words. The arguments must
-- have equal bit width, and the result is of the same width. It is
-- illegal to call with a second argument concretely equal to 0.
wordDiv :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement unsigned modulus of packed words. The arguments must
-- have equal bit width, and the result is of the same width. It is
-- illegal to call with a second argument concretely equal to 0.
wordMod :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement signed division of packed words. The arguments must
-- have equal bit width, and the result is of the same width. It is
-- illegal to call with a second argument concretely equal to 0.
wordSignedDiv :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement signed modulus of packed words. The arguments must have
-- equal bit width, and the result is of the same width. It is illegal to
-- call with a second argument concretely equal to 0.
wordSignedMod :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Shift a bitvector left by the specified amount. The shift amount is
-- considered as an unsigned value. Shifting by more than the word length
-- results in 0.
wordShiftLeft :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Shift a bitvector right by the specified amount. This is a logical
-- shift, which shifts in 0 values on the left. The shift amount is
-- considered as an unsigned value. Shifting by more than the word length
-- results in 0.
wordShiftRight :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Shift a bitvector right by the specified amount. This is an arithmetic
-- shift, which shifts in copies of the high bit on the left. The shift
-- amount is considered as an unsigned value. Shifting by more than the
-- word length results in filling the bitvector with the high bit.
wordSignedShiftRight :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
wordRotateLeft :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
wordRotateRight :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement negation of bitvectors
wordNegate :: Backend sym => sym -> SWord sym -> SEval sym (SWord sym)
-- | Compute rounded-up log-2 of the input
wordLg2 :: Backend sym => sym -> SWord sym -> SEval sym (SWord sym)
-- | Test if two words are equal. Arguments must have the same width.
wordEq :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SBit sym)
-- | Signed less-than comparison on words. Arguments must have the same
-- width.
wordSignedLessThan :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SBit sym)
-- | Unsigned less-than comparison on words. Arguments must have the same
-- width.
wordLessThan :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SBit sym)
-- | Unsigned greater-than comparison on words. Arguments must have the
-- same width.
wordGreaterThan :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SBit sym)
-- | Construct an integer value from the given packed word.
wordToInt :: Backend sym => sym -> SWord sym -> SEval sym (SInteger sym)
-- | Construct a signed integer value from the given packed word.
wordToSignedInt :: Backend sym => sym -> SWord sym -> SEval sym (SInteger sym)
-- | Addition of unbounded integers.
intPlus :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Negation of unbounded integers
intNegate :: Backend sym => sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Subtraction of unbounded integers.
intMinus :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Multiplication of unbounded integers.
intMult :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Integer division, rounding down. It is illegal to call with a second
-- argument concretely equal to 0. Same semantics as Haskell's
-- div operation.
intDiv :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Integer modulus, with division rounding down. It is illegal to call
-- with a second argument concretely equal to 0. Same semantics as
-- Haskell's mod operation.
intMod :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Equality comparison on integers
intEq :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SBit sym)
-- | Less-than comparison on integers
intLessThan :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SBit sym)
-- | Greater-than comparison on integers
intGreaterThan :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SBit sym)
-- | Turn an integer into a value in Z_n
intToZn :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SInteger sym)
-- | Transform a Z_n value into an integer, ensuring the value is properly
-- reduced modulo n
znToInt :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SInteger sym)
-- | Addition of integers modulo n, for a concrete positive integer n.
znPlus :: Backend sym => sym -> Integer -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Additive inverse of integers modulo n
znNegate :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SInteger sym)
-- | Subtraction of integers modulo n, for a concrete positive integer n.
znMinus :: Backend sym => sym -> Integer -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Multiplication of integers modulo n, for a concrete positive integer
-- n.
znMult :: Backend sym => sym -> Integer -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Equality test of integers modulo n
znEq :: Backend sym => sym -> Integer -> SInteger sym -> SInteger sym -> SEval sym (SBit sym)
-- | Multiplicative inverse in (Z n). PRECONDITION: the modulus is a prime
znRecip :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SInteger sym)
fpEq :: Backend sym => sym -> SFloat sym -> SFloat sym -> SEval sym (SBit sym)
fpLessThan :: Backend sym => sym -> SFloat sym -> SFloat sym -> SEval sym (SBit sym)
fpGreaterThan :: Backend sym => sym -> SFloat sym -> SFloat sym -> SEval sym (SBit sym)
fpLogicalEq :: Backend sym => sym -> SFloat sym -> SFloat sym -> SEval sym (SBit sym)
fpNaN :: Backend sym => sym -> Integer -> Integer -> SEval sym (SFloat sym)
fpPosInf :: Backend sym => sym -> Integer -> Integer -> SEval sym (SFloat sym)
fpPlus :: Backend sym => FPArith2 sym
fpMinus :: Backend sym => FPArith2 sym
fpMult :: Backend sym => FPArith2 sym
fpDiv :: Backend sym => FPArith2 sym
fpNeg :: Backend sym => sym -> SFloat sym -> SEval sym (SFloat sym)
fpAbs :: Backend sym => sym -> SFloat sym -> SEval sym (SFloat sym)
fpSqrt :: Backend sym => sym -> SWord sym -> SFloat sym -> SEval sym (SFloat sym)
fpFMA :: Backend sym => sym -> SWord sym -> SFloat sym -> SFloat sym -> SFloat sym -> SEval sym (SFloat sym)
fpIsZero :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsNeg :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsNaN :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsInf :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsNorm :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsSubnorm :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpToBits :: Backend sym => sym -> SFloat sym -> SEval sym (SWord sym)
fpFromBits :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SEval sym (SFloat sym)
fpToInteger :: Backend sym => sym -> String -> SWord sym -> SFloat sym -> SEval sym (SInteger sym)
fpFromInteger :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SInteger sym -> SEval sym (SFloat sym)
fpToRational :: Backend sym => sym -> SFloat sym -> SEval sym (SRational sym)
fpFromRational :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SRational sym -> SEval sym (SFloat sym)
-- | Delay the given evaluation computation, returning a thunk which will
-- run the computation when forced. Raise a loop error if the resulting
-- thunk is forced during its own evaluation.
sDelay :: Backend sym => sym -> SEval sym a -> SEval sym (SEval sym a)
invalidIndex :: Backend sym => sym -> Integer -> SEval sym a
cryUserError :: Backend sym => sym -> String -> SEval sym a
cryNoPrimError :: Backend sym => sym -> Name -> SEval sym a
type FPArith2 sym = sym -> SWord sym -> SFloat sym -> SFloat sym -> SEval sym (SFloat sym)
data IndexDirection
IndexForward :: IndexDirection
IndexBackward :: IndexDirection
-- | Compute the list of bits in an integer in big-endian order. Fails if
-- neither the sequence length nor the type value provide an upper bound
-- for the integer.
enumerateIntBits :: Backend sym => sym -> Nat' -> SInteger sym -> SEval sym (Integer, [SBit sym])
-- | Compute the list of bits in an integer in big-endian order. The
-- integer argument is a concrete upper bound for the symbolic integer.
enumerateIntBits' :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (Integer, [SBit sym])
-- | Representation of rational numbers. Invariant: denominator is not 0
data SRational sym
SRational :: SInteger sym -> SInteger sym -> SRational sym
[sNum] :: SRational sym -> SInteger sym
[sDenom] :: SRational sym -> SInteger sym
intToRational :: Backend sym => sym -> SInteger sym -> SEval sym (SRational sym)
ratio :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SRational sym)
rationalAdd :: Backend sym => sym -> SRational sym -> SRational sym -> SEval sym (SRational sym)
rationalSub :: Backend sym => sym -> SRational sym -> SRational sym -> SEval sym (SRational sym)
rationalNegate :: Backend sym => sym -> SRational sym -> SEval sym (SRational sym)
rationalMul :: Backend sym => sym -> SRational sym -> SRational sym -> SEval sym (SRational sym)
rationalRecip :: Backend sym => sym -> SRational sym -> SEval sym (SRational sym)
rationalDivide :: Backend sym => sym -> SRational sym -> SRational sym -> SEval sym (SRational sym)
rationalFloor :: Backend sym => sym -> SRational sym -> SEval sym (SInteger sym)
rationalCeiling :: Backend sym => sym -> SRational sym -> SEval sym (SInteger sym)
rationalTrunc :: Backend sym => sym -> SRational sym -> SEval sym (SInteger sym)
rationalRoundAway :: Backend sym => sym -> SRational sym -> SEval sym (SInteger sym)
rationalRoundToEven :: Backend sym => sym -> SRational sym -> SEval sym (SInteger sym)
rationalEq :: Backend sym => sym -> SRational sym -> SRational sym -> SEval sym (SBit sym)
rationalLessThan :: Backend sym => sym -> SRational sym -> SRational sym -> SEval sym (SBit sym)
rationalGreaterThan :: Backend sym => sym -> SRational sym -> SRational sym -> SEval sym (SBit sym)
iteRational :: Backend sym => sym -> SBit sym -> SRational sym -> SRational sym -> SEval sym (SRational sym)
module Cryptol.ModuleSystem.Renamer
-- | The NamingEnv is used by the renamer to determine what
-- identifiers refer to.
data NamingEnv
-- | Like mappend, but when merging, prefer values on the lhs.
shadowing :: NamingEnv -> NamingEnv -> NamingEnv
-- | Things that define exported names.
class BindsNames a
namingEnv :: BindsNames a => a -> BuildNamingEnv
-- | Do somethign in context. If Nothing than we are working with a
-- local declaration. Otherwise we are at the top-level of the given
-- module.
data InModule a
InModule :: Maybe ModPath -> a -> InModule a
-- | Shadow the current naming environment with some more names.
shadowNames :: BindsNames env => env -> RenameM a -> RenameM a
class Rename f
rename :: Rename f => f PName -> RenameM (f Name)
runRenamer :: RenamerInfo -> RenameM a -> (Either [RenamerError] (a, Supply), [RenamerWarning])
data RenameM a
data RenamerError
-- | Multiple imported symbols contain this name
MultipleSyms :: Located PName -> [Name] -> RenamerError
-- | Some name not bound to any definition
UnboundName :: Namespace -> Located PName -> RenamerError
-- | An environment has produced multiple overlapping symbols
OverlappingSyms :: [Name] -> RenamerError
-- | expected, actual. When a name is missing from the expected namespace,
-- but exists in another
WrongNamespace :: Namespace -> Namespace -> Located PName -> RenamerError
-- | When the fixity of two operators conflict
FixityError :: Located Name -> Fixity -> Located Name -> Fixity -> RenamerError
-- | When it's not possible to produce a Prop from a Type.
InvalidConstraint :: Type PName -> RenamerError
-- | When a builtin type/type-function is used incorrectly.
MalformedBuiltin :: Type PName -> PName -> RenamerError
-- | When a builtin type is named in a binder.
BoundReservedType :: PName -> Maybe Range -> Doc -> RenamerError
-- | When record updates overlap (e.g., { r | x = e1, x.y = e2 })
OverlappingRecordUpdate :: Located [Selector] -> Located [Selector] -> RenamerError
InvalidDependency :: [DepName] -> RenamerError
data RenamerWarning
SymbolShadowed :: PName -> Name -> [Name] -> RenamerWarning
UnusedName :: Name -> RenamerWarning
renameVar :: NameType -> PName -> RenameM Name
renameType :: NameType -> PName -> RenameM Name
renameModule :: Module PName -> RenameM RenamedModule
renameTopDecls :: ModName -> [TopDecl PName] -> RenameM (NamingEnv, [TopDecl Name])
-- | Information needed to do some renaming.
data RenamerInfo
RenamerInfo :: Supply -> ModPath -> NamingEnv -> (ModName -> Iface) -> RenamerInfo
-- | Use to make new names
[renSupply] :: RenamerInfo -> Supply
-- | We are renaming things in here
[renContext] :: RenamerInfo -> ModPath
-- | This is what's in scope
[renEnv] :: RenamerInfo -> NamingEnv
[renIfaces] :: RenamerInfo -> ModName -> Iface
-- | Indicates if a name is in a binding poisition or a use site
data NameType
NameBind :: NameType
NameUse :: NameType
data RenamedModule
RenamedModule :: Module Name -> NamingEnv -> NamingEnv -> IfaceDecls -> RenamedModule
-- | The renamed module
[rmModule] :: RenamedModule -> Module Name
-- | What this module defines
[rmDefines] :: RenamedModule -> NamingEnv
-- | What's in scope in this module
[rmInScope] :: RenamedModule -> NamingEnv
-- | Imported declarations
[rmImported] :: RenamedModule -> IfaceDecls
instance Cryptol.ModuleSystem.Renamer.Rename (Cryptol.ModuleSystem.Renamer.WithMods Cryptol.Parser.AST.TopDecl)
instance Cryptol.ModuleSystem.Renamer.Rename (Cryptol.ModuleSystem.Renamer.WithMods Cryptol.Parser.AST.NestedModule)
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.ImpName
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.PrimType
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.ParameterType
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.ParameterFun
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.Decl
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.Newtype
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.Schema
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.TParam
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.Prop
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.Type
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.Bind
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.BindDef
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.Pattern
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.UpdField
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.FunDesc
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.Expr
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.TypeInst
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.Match
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.TySyn
instance Cryptol.ModuleSystem.Renamer.Rename Cryptol.Parser.AST.PropSyn
module Cryptol.IR.FreeVars
class FreeVars e
freeVars :: FreeVars e => e -> Deps
data Deps
Deps :: Set Name -> Set Name -> Set TParam -> Deps
-- | Undefined value names
[valDeps] :: Deps -> Set Name
-- | Undefined type names (from newtype)
[tyDeps] :: Deps -> Set Name
-- | Undefined type params (e.d. mod params)
[tyParams] :: Deps -> Set TParam
class Defs d
defs :: Defs d => d -> Set Name
-- | Dependencies of top-level declarations in a module. These are
-- dependencies on module parameters or things defined outside the
-- module.
moduleDeps :: Module -> Map Name Deps
-- | Compute the transitive closure of the given dependencies.
transDeps :: Map Name Deps -> Map Name Deps
instance GHC.Classes.Eq Cryptol.IR.FreeVars.Deps
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.AST.DeclGroup
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.AST.Expr
instance Cryptol.IR.FreeVars.Defs a => Cryptol.IR.FreeVars.Defs [a]
instance Cryptol.IR.FreeVars.Defs Cryptol.TypeCheck.AST.DeclGroup
instance Cryptol.IR.FreeVars.Defs Cryptol.TypeCheck.AST.Decl
instance Cryptol.IR.FreeVars.Defs Cryptol.TypeCheck.AST.Match
instance Cryptol.IR.FreeVars.FreeVars e => Cryptol.IR.FreeVars.FreeVars [e]
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.AST.Decl
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.AST.DeclDef
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.AST.Match
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.Type.Schema
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.Type.Type
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.Type.TVar
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.TCon.TCon
instance Cryptol.IR.FreeVars.FreeVars Cryptol.TypeCheck.Type.Newtype
instance GHC.Base.Semigroup Cryptol.IR.FreeVars.Deps
instance GHC.Base.Monoid Cryptol.IR.FreeVars.Deps
module Cryptol.Eval.Type
-- | An evaluated type of kind *. These types do not contain type
-- variables, type synonyms, or type functions.
data TValue
-- |
-- Bit
--
TVBit :: TValue
-- |
-- Integer
--
TVInteger :: TValue
-- |
-- Float e p
--
TVFloat :: Integer -> Integer -> TValue
-- |
-- Z n
--
TVIntMod :: Integer -> TValue
-- |
-- Rational
--
TVRational :: TValue
-- |
-- Array a b
--
TVArray :: TValue -> TValue -> TValue
-- |
-- [n]a
--
TVSeq :: Integer -> TValue -> TValue
-- |
-- [inf]t
--
TVStream :: TValue -> TValue
-- |
-- (a, b, c )
--
TVTuple :: [TValue] -> TValue
-- |
-- { x : a, y : b, z : c }
--
TVRec :: RecordMap Ident TValue -> TValue
-- |
-- a -> b
--
TVFun :: TValue -> TValue -> TValue
-- | a named newtype
TVNewtype :: Newtype -> [Either Nat' TValue] -> RecordMap Ident TValue -> TValue
-- | an abstract type
TVAbstract :: UserTC -> [Either Nat' TValue] -> TValue
-- | Convert a type value back into a regular type
tValTy :: TValue -> Type
tNumTy :: Nat' -> Type
tNumValTy :: Either Nat' TValue -> Type
-- | True if the evaluated value is Bit
isTBit :: TValue -> Bool
-- | Produce a sequence type value
tvSeq :: Nat' -> TValue -> TValue
-- | Coerce an extended natural into an integer, for values known to be
-- finite
finNat' :: Nat' -> Integer
newtype TypeEnv
TypeEnv :: IntMap (Either Nat' TValue) -> TypeEnv
[envTypeMap] :: TypeEnv -> IntMap (Either Nat' TValue)
lookupTypeVar :: TVar -> TypeEnv -> Maybe (Either Nat' TValue)
bindTypeVar :: TVar -> Either Nat' TValue -> TypeEnv -> TypeEnv
-- | Evaluation for types (kind * or #).
evalType :: TypeEnv -> Type -> Either Nat' TValue
-- | Evaluate the body of a newtype, given evaluated arguments
evalNewtypeBody :: TypeEnv -> Newtype -> [Either Nat' TValue] -> RecordMap Ident TValue
-- | Evaluation for value types (kind *).
evalValType :: TypeEnv -> Type -> TValue
-- | Evaluation for number types (kind #).
evalNumType :: TypeEnv -> Type -> Nat'
-- | Reduce type functions, raising an exception for undefined values.
evalTF :: TFun -> [Nat'] -> Nat'
instance GHC.Classes.Eq Cryptol.Eval.Type.TValue
instance Control.DeepSeq.NFData Cryptol.Eval.Type.TValue
instance GHC.Generics.Generic Cryptol.Eval.Type.TValue
instance GHC.Base.Monoid Cryptol.Eval.Type.TypeEnv
instance GHC.Base.Semigroup Cryptol.Eval.Type.TypeEnv
instance GHC.Show.Show Cryptol.Eval.Type.TValue
-- | This module provides fast primitives for elliptic curve cryptography
-- defined on Z p for prime p > 3. These are exposed
-- in cryptol by importing the built-in module PrimeEC. The
-- primary primitives exposed here are the doubling and addition
-- primitives in the ECC group as well as scalar multiplication and the
-- "twin" multiplication primitive, which simultaneously computes the
-- addition of two scalar multiplies.
--
-- This module makes heavy use of some GHC internals regarding the
-- representation of the Integer type, and the underlying GMP primitives
-- in order to speed up the basic modular arithmetic operations.
module Cryptol.PrimeEC
-- | Simple newtype wrapping the BigNat value of the modulus of
-- the underlying field Z p. This modulus is required to be prime.
data PrimeModulus
-- | Inject an integer value into the PrimeModulus type. This
-- modulus is required to be prime.
primeModulus :: Integer -> PrimeModulus
-- | Points in the projective plane represented in homogenous coordinates.
data ProjectivePoint
ProjectivePoint :: !BigNat# -> !BigNat# -> !BigNat# -> ProjectivePoint
[px] :: ProjectivePoint -> !BigNat#
[py] :: ProjectivePoint -> !BigNat#
[pz] :: ProjectivePoint -> !BigNat#
toProjectivePoint :: Integer -> Integer -> Integer -> ProjectivePoint
integerToBigNat :: Integer -> BigNat#
bigNatToInteger :: BigNat -> Integer
-- | Compute the elliptic curve group doubling operation. In other words,
-- if S is a projective point on a curve, this operation
-- computes S+S in the ECC group.
--
-- In geometric terms, this operation computes a tangent line to the
-- curve at S and finds the (unique) intersection point of this
-- line with the curve, R; then returns the point R',
-- which is R reflected across the x axis.
ec_double :: PrimeModulus -> ProjectivePoint -> ProjectivePoint
-- | Compute the elliptic curve group addition operation for values known
-- not to be the identity. In other words, if S and T
-- are projective points on a curve, with nonzero z coordinate
-- this operation computes S+T in the ECC group.
--
-- In geometric terms, this operation computes a line that passes through
-- S and T, and finds the (unique) other point
-- R where the line intersects the curve; then returns the point
-- R', which is R reflected across the x axis. In the
-- special case where S == T, we instead call the
-- ec_double operation, which instead computes a tangent line to
-- S .
ec_add_nonzero :: PrimeModulus -> ProjectivePoint -> ProjectivePoint -> ProjectivePoint
-- | Given an integer k and a projective point S, compute
-- the scalar multiplication kS, which is S added to
-- itself k times.
ec_mult :: PrimeModulus -> Integer -> ProjectivePoint -> ProjectivePoint
-- | Given an integer j and a projective point S,
-- together with another integer k and point T compute
-- the "twin" scalar the scalar multiplication jS + kT. This
-- computation can be done essentially the same number of modular
-- arithmetic operations as a single scalar multiplication by doing some
-- additional bookkeeping and setup.
ec_twin_mult :: PrimeModulus -> Integer -> ProjectivePoint -> Integer -> ProjectivePoint -> ProjectivePoint
module Cryptol.Backend.What4
data What4 sym
What4 :: sym -> MVar (Pred sym) -> MVar (What4FunCache sym) -> MVar (Set Text) -> What4 sym
[w4] :: What4 sym -> sym
[w4defs] :: What4 sym -> MVar (Pred sym)
[w4funs] :: What4 sym -> MVar (What4FunCache sym)
[w4uninterpWarns] :: What4 sym -> MVar (Set Text)
type What4FunCache sym = Map Text (SomeSymFn sym)
data SomeSymFn sym
SomeSymFn :: SymFn sym args ret -> SomeSymFn sym
-- | This is the monad used for symbolic evaluation. It adds to aspects to
-- Eval---WConn keeps track of the backend and collects
-- definitional predicates, and W4Eval adds support for partially
-- defined values
newtype W4Eval sym a
W4Eval :: W4Conn sym (W4Result sym a) -> W4Eval sym a
[evalPartial] :: W4Eval sym a -> W4Conn sym (W4Result sym a)
-- | This layer has the symbolic back-end, and can keep track of
-- definitional predicates used when working with uninterpreted constants
-- defined via a property.
newtype W4Conn sym a
W4Conn :: (sym -> Eval a) -> W4Conn sym a
[evalConn] :: W4Conn sym a -> sym -> Eval a
-- | The symbolic value we computed.
data W4Result sym a
-- | A malformed value
W4Error :: !EvalErrorEx -> W4Result sym a
-- | safety predicate and result: the result only makes sense when the
-- predicate holds.
W4Result :: !Pred sym -> !a -> W4Result sym a
w4Eval :: W4Eval sym a -> sym -> Eval (W4Result sym a)
w4Thunk :: Eval (W4Result sym a) -> W4Eval sym a
-- | A value with no context.
doEval :: IsSymExprBuilder sym => Eval a -> W4Conn sym a
-- | A total value.
total :: IsSymExprBuilder sym => W4Conn sym a -> W4Eval sym a
-- | Access the symbolic back-end
getSym :: W4Conn sym sym
-- | Record a definition. addDef :: W4.Pred sym -> W4Conn sym () addDef
-- p = W4Conn _ -> pure W4Defs { w4Defs = p, w4Result = () }
--
-- Compute conjunction.
w4And :: IsSymExprBuilder sym => Pred sym -> Pred sym -> W4Conn sym (Pred sym)
-- | Compute negation.
w4Not :: IsSymExprBuilder sym => Pred sym -> W4Conn sym (Pred sym)
-- | Compute if-then-else.
w4ITE :: IsSymExprBuilder sym => Pred sym -> Pred sym -> Pred sym -> W4Conn sym (Pred sym)
-- | Add a definitional equation. This will always be asserted when we make
-- queries to the solver.
addDefEqn :: IsSymExprBuilder sym => What4 sym -> Pred sym -> W4Eval sym ()
-- | Add s safety condition.
addSafety :: IsSymExprBuilder sym => Pred sym -> W4Eval sym ()
-- | A fully undefined symbolic value
evalError :: IsSymExprBuilder sym => EvalError -> W4Eval sym a
assertBVDivisor :: IsSymExprBuilder sym => What4 sym -> SWord sym -> W4Eval sym ()
assertIntDivisor :: IsSymExprBuilder sym => What4 sym -> SymInteger sym -> W4Eval sym ()
sModAdd :: IsSymExprBuilder sym => sym -> Integer -> SymInteger sym -> SymInteger sym -> IO (SymInteger sym)
sModSub :: IsSymExprBuilder sym => sym -> Integer -> SymInteger sym -> SymInteger sym -> IO (SymInteger sym)
sModMult :: IsSymExprBuilder sym => sym -> Integer -> SymInteger sym -> SymInteger sym -> IO (SymInteger sym)
sModNegate :: IsSymExprBuilder sym => sym -> Integer -> SymInteger sym -> IO (SymInteger sym)
-- | Try successive powers of 2 to find the first that dominates the input.
-- We could perhaps reduce to using CLZ instead...
sLg2 :: IsSymExprBuilder sym => sym -> SWord sym -> SEval (What4 sym) (SWord sym)
evalPanic :: String -> [String] -> a
lazyIte :: (IsExpr p, Monad m) => (p BaseBoolType -> a -> a -> m a) -> p BaseBoolType -> m a -> m a -> m a
w4bvShl :: IsSymExprBuilder sym => sym -> SWord sym -> SWord sym -> W4Eval sym (SWord sym)
w4bvLshr :: IsSymExprBuilder sym => sym -> SWord sym -> SWord sym -> W4Eval sym (SWord sym)
w4bvAshr :: IsSymExprBuilder sym => sym -> SWord sym -> SWord sym -> W4Eval sym (SWord sym)
w4bvRol :: IsSymExprBuilder sym => sym -> SWord sym -> SWord sym -> W4Eval sym (SWord sym)
w4bvRor :: IsSymExprBuilder sym => sym -> SWord sym -> SWord sym -> W4Eval sym (SWord sym)
fpRoundingMode :: IsSymExprBuilder sym => What4 sym -> SWord (What4 sym) -> SEval (What4 sym) RoundingMode
fpBinArith :: IsSymExprBuilder sym => SFloatBinArith sym -> What4 sym -> SWord (What4 sym) -> SFloat (What4 sym) -> SFloat (What4 sym) -> SEval (What4 sym) (SFloat (What4 sym))
fpCvtToInteger :: (IsSymExprBuilder sy, sym ~ What4 sy) => sym -> String -> SWord sym -> SFloat sym -> SEval sym (SInteger sym)
fpCvtToRational :: (IsSymExprBuilder sy, sym ~ What4 sy) => sym -> SFloat sym -> SEval sym (SRational sym)
fpCvtFromRational :: (IsSymExprBuilder sy, sym ~ What4 sy) => sym -> Integer -> Integer -> SWord sym -> SRational sym -> SEval sym (SFloat sym)
sModRecip :: IsSymExprBuilder sym => What4 sym -> Integer -> SymInteger sym -> W4Eval sym (SymInteger sym)
instance GHC.Base.Functor (Cryptol.Backend.What4.W4Result sym)
instance What4.Interface.IsSymExprBuilder sym => GHC.Base.Functor (Cryptol.Backend.What4.W4Eval sym)
instance What4.Interface.IsSymExprBuilder sym => GHC.Base.Applicative (Cryptol.Backend.What4.W4Eval sym)
instance What4.Interface.IsSymExprBuilder sym => GHC.Base.Monad (Cryptol.Backend.What4.W4Eval sym)
instance What4.Interface.IsSymExprBuilder sym => Control.Monad.IO.Class.MonadIO (Cryptol.Backend.What4.W4Eval sym)
instance What4.Interface.IsSymExprBuilder sym => Cryptol.Backend.Backend (Cryptol.Backend.What4.What4 sym)
instance What4.Interface.IsSymExprBuilder sym => GHC.Base.Functor (Cryptol.Backend.What4.W4Conn sym)
instance What4.Interface.IsSymExprBuilder sym => GHC.Base.Applicative (Cryptol.Backend.What4.W4Conn sym)
instance What4.Interface.IsSymExprBuilder sym => GHC.Base.Monad (Cryptol.Backend.What4.W4Conn sym)
instance What4.Interface.IsSymExprBuilder sym => Control.Monad.IO.Class.MonadIO (Cryptol.Backend.What4.W4Conn sym)
module Cryptol.Backend.Concrete
-- | Concrete bitvector values: width, value Invariant: The value must be
-- within the range 0 .. 2^width-1
data BV
BV :: !Integer -> !Integer -> BV
-- | Apply an integer function to the values of bitvectors. This function
-- assumes both bitvectors are the same width.
binBV :: Applicative m => (Integer -> Integer -> Integer) -> BV -> BV -> m BV
-- | Apply an integer function to the values of a bitvector. This function
-- assumes the function will not require masking.
unaryBV :: (Integer -> Integer) -> BV -> BV
bvVal :: BV -> Integer
ppBV :: PPOpts -> BV -> Doc
-- | Smart constructor for BVs that checks for the width limit
mkBv :: Integer -> Integer -> BV
mask :: Integer -> Integer -> Integer
signedBV :: BV -> Integer
signedValue :: Integer -> Integer -> Integer
integerToChar :: Integer -> Char
lg2 :: Integer -> Integer
data Concrete
Concrete :: Concrete
liftBinIntMod :: Monad m => (Integer -> Integer -> Integer) -> Integer -> Integer -> Integer -> m Integer
fpBinArith :: (BFOpts -> BigFloat -> BigFloat -> (BigFloat, Status)) -> Concrete -> SWord Concrete -> SFloat Concrete -> SFloat Concrete -> SEval Concrete (SFloat Concrete)
fpRoundMode :: Concrete -> SWord Concrete -> SEval Concrete RoundMode
instance GHC.Show.Show Cryptol.Backend.Concrete.Concrete
instance GHC.Show.Show Cryptol.Backend.Concrete.BV
instance Cryptol.Backend.Backend Cryptol.Backend.Concrete.Concrete
module Cryptol.Backend.SeqMap
-- | A sequence map represents a mapping from nonnegative integer indices
-- to values. These are used to represent both finite and infinite
-- sequences.
data SeqMap sym a
indexSeqMap :: (Integer -> SEval sym a) -> SeqMap sym a
lookupSeqMap :: Backend sym => SeqMap sym a -> Integer -> SEval sym a
-- | Generate a finite sequence map from a list of values
finiteSeqMap :: Backend sym => sym -> [SEval sym a] -> SeqMap sym a
-- | Generate an infinite sequence map from a stream of values
infiniteSeqMap :: Backend sym => sym -> [SEval sym a] -> SEval sym (SeqMap sym a)
-- | Create a finite list of length n of the values from
-- [0..n-1] in the given the sequence emap.
enumerateSeqMap :: (Backend sym, Integral n) => n -> SeqMap sym a -> [SEval sym a]
-- | Create an infinite stream of all the values in a sequence map
streamSeqMap :: Backend sym => SeqMap sym a -> [SEval sym a]
-- | Reverse the order of a finite sequence map
reverseSeqMap :: Backend sym => Integer -> SeqMap sym a -> SeqMap sym a
updateSeqMap :: SeqMap sym a -> Integer -> SEval sym a -> SeqMap sym a
-- | Drop the first n elements of the given SeqMap.
dropSeqMap :: Backend sym => Integer -> SeqMap sym a -> SeqMap sym a
-- | Concatenate the first n values of the first sequence map onto
-- the beginning of the second sequence map.
concatSeqMap :: Backend sym => Integer -> SeqMap sym a -> SeqMap sym a -> SeqMap sym a
-- | Given a number n and a sequence map, return two new sequence
-- maps: the first containing the values from [0..n-1] and the
-- next containing the values from n onward.
splitSeqMap :: Backend sym => Integer -> SeqMap sym a -> (SeqMap sym a, SeqMap sym a)
-- | Given a sequence map, return a new sequence map that is memoized using
-- a finite map memo table.
memoMap :: Backend sym => sym -> Nat' -> SeqMap sym a -> SEval sym (SeqMap sym a)
delaySeqMap :: Backend sym => sym -> SEval sym (SeqMap sym a) -> SEval sym (SeqMap sym a)
-- | Apply the given evaluation function pointwise to the two given
-- sequence maps.
zipSeqMap :: Backend sym => sym -> (a -> a -> SEval sym a) -> Nat' -> SeqMap sym a -> SeqMap sym a -> SEval sym (SeqMap sym a)
-- | Apply the given function to each value in the given sequence map
mapSeqMap :: Backend sym => sym -> (a -> SEval sym a) -> Nat' -> SeqMap sym a -> SEval sym (SeqMap sym a)
mergeSeqMap :: Backend sym => sym -> (SBit sym -> a -> a -> SEval sym a) -> SBit sym -> SeqMap sym a -> SeqMap sym a -> SeqMap sym a
barrelShifter :: Backend sym => sym -> (SBit sym -> a -> a -> SEval sym a) -> (SeqMap sym a -> Integer -> SEval sym (SeqMap sym a)) -> Nat' -> SeqMap sym a -> Integer -> [IndexSegment sym] -> SEval sym (SeqMap sym a)
shiftSeqByInteger :: Backend sym => sym -> (SBit sym -> a -> a -> SEval sym a) -> (Integer -> Integer -> Maybe Integer) -> SEval sym a -> Nat' -> SeqMap sym a -> SInteger sym -> SEval sym (SeqMap sym a)
data IndexSegment sym
BitIndexSegment :: SBit sym -> IndexSegment sym
WordIndexSegment :: SWord sym -> IndexSegment sym
instance Cryptol.Backend.Backend sym => GHC.Base.Functor (Cryptol.Backend.SeqMap.SeqMap sym)
module Cryptol.Backend.WordValue
-- | For efficiency reasons, we handle finite sequences of bits as special
-- cases in the evaluator. In cases where we know it is safe to do so, we
-- prefer to used a "packed word" representation of bit sequences. This
-- allows us to rely directly on Integer types (in the concrete
-- evaluator) and SBV's Word types (in the symbolic simulator).
--
-- However, if we cannot be sure all the bits of the sequence will
-- eventually be forced, we must instead rely on an explicit sequence of
-- bits representation.
data WordValue sym
wordVal :: SWord sym -> WordValue sym
bitmapWordVal :: Backend sym => sym -> Integer -> SeqMap sym (SBit sym) -> SEval sym (WordValue sym)
asWordList :: forall sym. Backend sym => sym -> [WordValue sym] -> SEval sym (Maybe [SWord sym])
-- | Force a word value into packed word form
asWordVal :: Backend sym => sym -> WordValue sym -> SEval sym (SWord sym)
-- | Force a word value into a sequence of bits
asBitsMap :: Backend sym => sym -> WordValue sym -> SeqMap sym (SBit sym)
joinWordVal :: Backend sym => sym -> WordValue sym -> WordValue sym -> SEval sym (WordValue sym)
takeWordVal :: Backend sym => sym -> Integer -> Integer -> WordValue sym -> SEval sym (WordValue sym)
dropWordVal :: Backend sym => sym -> Integer -> Integer -> WordValue sym -> SEval sym (WordValue sym)
-- | Extract a subsequence of bits from a WordValue. The first
-- integer argument is the number of bits in the resulting word. The
-- second integer argument is the number of less-significant digits to
-- discard. Stated another way, the operation `extractWordVal n i w` is
-- equivalent to first shifting w right by i bits, and
-- then truncating to n bits.
extractWordVal :: Backend sym => sym -> Integer -> Integer -> WordValue sym -> SEval sym (WordValue sym)
wordValLogicOp :: Backend sym => sym -> (SBit sym -> SBit sym -> SEval sym (SBit sym)) -> (SWord sym -> SWord sym -> SEval sym (SWord sym)) -> WordValue sym -> WordValue sym -> SEval sym (WordValue sym)
wordValUnaryOp :: Backend sym => sym -> (SBit sym -> SEval sym (SBit sym)) -> (SWord sym -> SEval sym (SWord sym)) -> WordValue sym -> SEval sym (WordValue sym)
assertWordValueInBounds :: Backend sym => sym -> Integer -> WordValue sym -> SEval sym ()
-- | Turn a word value into a sequence of bits, forcing each bit. The
-- sequence is returned in big-endian order.
enumerateWordValue :: Backend sym => sym -> WordValue sym -> SEval sym [SBit sym]
-- | Turn a word value into a sequence of bits, forcing each bit. The
-- sequence is returned in reverse of the usual order, which is
-- little-endian order.
enumerateWordValueRev :: Backend sym => sym -> WordValue sym -> SEval sym [SBit sym]
enumerateIndexSegments :: Backend sym => sym -> WordValue sym -> SEval sym [IndexSegment sym]
-- | Compute the size of a word value TODO, can we get rid of this? If
-- feels like it should be unnecessary.
wordValueSize :: Backend sym => sym -> WordValue sym -> Integer
-- | Select an individual bit from a word value
indexWordValue :: Backend sym => sym -> WordValue sym -> Integer -> SEval sym (SBit sym)
-- | Produce a new WordValue from the one given by updating the
-- ith bit with the given bit value.
updateWordValue :: Backend sym => sym -> WordValue sym -> Integer -> SEval sym (SBit sym) -> SEval sym (WordValue sym)
delayWordValue :: Backend sym => sym -> Integer -> SEval sym (WordValue sym) -> SEval sym (WordValue sym)
joinWords :: forall sym. Backend sym => sym -> Integer -> Integer -> SeqMap sym (WordValue sym) -> SEval sym (WordValue sym)
shiftSeqByWord :: Backend sym => sym -> (SBit sym -> a -> a -> SEval sym a) -> (Integer -> Integer -> Maybe Integer) -> SEval sym a -> Nat' -> SeqMap sym a -> WordValue sym -> SEval sym (SeqMap sym a)
shiftWordByInteger :: Backend sym => sym -> (SWord sym -> SWord sym -> SEval sym (SWord sym)) -> (Integer -> Integer -> Maybe Integer) -> WordValue sym -> SInteger sym -> SEval sym (WordValue sym)
shiftWordByWord :: Backend sym => sym -> (SWord sym -> SWord sym -> SEval sym (SWord sym)) -> (Integer -> Integer -> Maybe Integer) -> WordValue sym -> WordValue sym -> SEval sym (WordValue sym)
wordValAsLit :: Backend sym => sym -> WordValue sym -> SEval sym (Maybe Integer)
reverseWordVal :: Backend sym => sym -> WordValue sym -> SEval sym (WordValue sym)
-- | Force the evaluation of a word value
forceWordValue :: Backend sym => WordValue sym -> SEval sym ()
wordValueEqualsInteger :: forall sym. Backend sym => sym -> WordValue sym -> Integer -> SEval sym (SBit sym)
updateWordByWord :: Backend sym => sym -> IndexDirection -> WordValue sym -> WordValue sym -> SEval sym (SBit sym) -> SEval sym (WordValue sym)
mergeWord :: Backend sym => sym -> SBit sym -> WordValue sym -> WordValue sym -> SEval sym (WordValue sym)
mergeWord' :: Backend sym => sym -> SBit sym -> SEval sym (WordValue sym) -> SEval sym (WordValue sym) -> SEval sym (WordValue sym)
instance GHC.Generics.Generic (Cryptol.Backend.WordValue.WordValue sym)
module Cryptol.Eval.Value
-- | Generic value type, parameterized by bit and word types.
--
-- NOTE: we maintain an important invariant regarding sequence types.
-- VSeq must never be used for finite sequences of bits. Always
-- use the VWord constructor instead! Infinite sequences of bits
-- are handled by the VStream constructor, just as for other
-- types.
data GenValue sym
-- |
-- { .. }
--
VRecord :: !RecordMap Ident (SEval sym (GenValue sym)) -> GenValue sym
-- |
-- ( .. )
--
VTuple :: ![SEval sym (GenValue sym)] -> GenValue sym
-- |
-- Bit
--
VBit :: !SBit sym -> GenValue sym
-- | Integer or Z n
VInteger :: !SInteger sym -> GenValue sym
-- |
-- Rational
--
VRational :: !SRational sym -> GenValue sym
VFloat :: !SFloat sym -> GenValue sym
-- | [n]a Invariant: VSeq is never a sequence of bits
VSeq :: !Integer -> !SeqMap sym (GenValue sym) -> GenValue sym
-- |
-- [n]Bit
--
VWord :: !Integer -> !WordValue sym -> GenValue sym
-- |
-- [inf]a
--
VStream :: !SeqMap sym (GenValue sym) -> GenValue sym
-- | functions
VFun :: CallStack -> (SEval sym (GenValue sym) -> SEval sym (GenValue sym)) -> GenValue sym
-- | polymorphic values (kind *)
VPoly :: CallStack -> (TValue -> SEval sym (GenValue sym)) -> GenValue sym
-- | polymorphic values (kind #)
VNumPoly :: CallStack -> (Nat' -> SEval sym (GenValue sym)) -> GenValue sym
-- | Force the evaluation of a value
forceValue :: Backend sym => GenValue sym -> SEval sym ()
-- | This type class defines a collection of operations on bits, words and
-- integers that are necessary to define generic evaluator primitives
-- that operate on both concrete and symbolic values uniformly.
class MonadIO (SEval sym) => Backend sym where {
type family SBit sym :: Type;
type family SWord sym :: Type;
type family SInteger sym :: Type;
type family SFloat sym :: Type;
type family SEval sym :: Type -> Type;
}
-- | Check if an operation is "ready", which means its evaluation will be
-- trivial.
isReady :: Backend sym => sym -> SEval sym a -> SEval sym (Maybe a)
-- | Produce a thunk value which can be filled with its associated
-- computation after the fact. A preallocated thunk is returned, along
-- with an operation to fill the thunk with the associated computation.
-- This is used to implement recursive declaration groups.
sDeclareHole :: Backend sym => sym -> String -> SEval sym (SEval sym a, SEval sym a -> SEval sym ())
-- | Delay the given evaluation computation, returning a thunk which will
-- run the computation when forced. Run the retry computation
-- instead if the resulting thunk is forced during its own evaluation.
sDelayFill :: Backend sym => sym -> SEval sym a -> Maybe (SEval sym a) -> String -> SEval sym (SEval sym a)
-- | Begin evaluating the given computation eagerly in a separate thread
-- and return a thunk which will await the completion of the given
-- computation when forced.
sSpark :: Backend sym => sym -> SEval sym a -> SEval sym (SEval sym a)
-- | Push a call frame on to the current call stack while evaluating the
-- given action
sPushFrame :: Backend sym => sym -> Name -> Range -> SEval sym a -> SEval sym a
-- | Use the given call stack while evaluating the given action
sWithCallStack :: Backend sym => sym -> CallStack -> SEval sym a -> SEval sym a
-- | Apply the given function to the current call stack while evaluating
-- the given action
sModifyCallStack :: Backend sym => sym -> (CallStack -> CallStack) -> SEval sym a -> SEval sym a
-- | Retrieve the current evaluation call stack
sGetCallStack :: Backend sym => sym -> SEval sym CallStack
-- | Merge the two given computations according to the predicate.
mergeEval :: Backend sym => sym -> (SBit sym -> a -> a -> SEval sym a) -> SBit sym -> SEval sym a -> SEval sym a -> SEval sym a
-- | Assert that a condition must hold, and indicate what sort of error is
-- indicated if the condition fails.
assertSideCondition :: Backend sym => sym -> SBit sym -> EvalError -> SEval sym ()
-- | Indiciate that an error condition exists
raiseError :: Backend sym => sym -> EvalError -> SEval sym a
-- | Determine if this symbolic bit is a boolean literal
bitAsLit :: Backend sym => sym -> SBit sym -> Maybe Bool
-- | The number of bits in a word value.
wordLen :: Backend sym => sym -> SWord sym -> Integer
-- | Determine if this symbolic word is a literal. If so, return the bit
-- width and value.
wordAsLit :: Backend sym => sym -> SWord sym -> Maybe (Integer, Integer)
-- | Attempt to render a word value as an ASCII character. Return
-- Nothing if the character value is unknown (e.g., for symbolic
-- values).
wordAsChar :: Backend sym => sym -> SWord sym -> Maybe Char
-- | Determine if this symbolic integer is a literal
integerAsLit :: Backend sym => sym -> SInteger sym -> Maybe Integer
-- | Determine if this symbolic floating-point value is a literal
fpAsLit :: Backend sym => sym -> SFloat sym -> Maybe BF
-- | Construct a literal bit value from a boolean.
bitLit :: Backend sym => sym -> Bool -> SBit sym
-- | Construct a literal word value given a bit width and a value.
wordLit :: Backend sym => sym -> Integer -> Integer -> SEval sym (SWord sym)
-- | Construct a literal integer value from the given integer.
integerLit :: Backend sym => sym -> Integer -> SEval sym (SInteger sym)
-- | Construct a floating point value from the given rational.
fpLit :: Backend sym => sym -> Integer -> Integer -> Rational -> SEval sym (SFloat sym)
-- | Construct a floating point value from the given bit-precise
-- floating-point representation.
fpExactLit :: Backend sym => sym -> BF -> SEval sym (SFloat sym)
iteBit :: Backend sym => sym -> SBit sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
iteWord :: Backend sym => sym -> SBit sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
iteInteger :: Backend sym => sym -> SBit sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
iteFloat :: Backend sym => sym -> SBit sym -> SFloat sym -> SFloat sym -> SEval sym (SFloat sym)
bitEq :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
bitOr :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
bitAnd :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
bitXor :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
bitComplement :: Backend sym => sym -> SBit sym -> SEval sym (SBit sym)
-- | Extract the numbered bit from the word.
--
-- NOTE: this assumes that the sequence of bits is big-endian and finite,
-- so the bit numbered 0 is the most significant bit.
wordBit :: Backend sym => sym -> SWord sym -> Integer -> SEval sym (SBit sym)
-- | Update the numbered bit in the word.
--
-- NOTE: this assumes that the sequence of bits is big-endian and finite,
-- so the bit numbered 0 is the most significant bit.
wordUpdate :: Backend sym => sym -> SWord sym -> Integer -> SBit sym -> SEval sym (SWord sym)
-- | Construct a word value from a finite sequence of bits. NOTE: this
-- assumes that the sequence of bits is big-endian and finite, so the
-- first element of the list will be the most significant bit.
packWord :: Backend sym => sym -> [SBit sym] -> SEval sym (SWord sym)
-- | Deconstruct a packed word value in to a finite sequence of bits. NOTE:
-- this produces a list of bits that represent a big-endian word, so the
-- most significant bit is the first element of the list.
unpackWord :: Backend sym => sym -> SWord sym -> SEval sym [SBit sym]
-- | Construct a packed word of the specified width from an integer value.
wordFromInt :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SWord sym)
-- | Concatenate the two given word values. NOTE: the first argument
-- represents the more-significant bits
joinWord :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Take the most-significant bits, and return those bits and the
-- remainder. The first element of the pair is the most significant bits.
-- The two integer sizes must sum to the length of the given word value.
splitWord :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SEval sym (SWord sym, SWord sym)
-- | Extract a subsequence of bits from a packed word value. The first
-- integer argument is the number of bits in the resulting word. The
-- second integer argument is the number of less-significant digits to
-- discard. Stated another way, the operation extractWord n i w
-- is equivalent to first shifting w right by i bits,
-- and then truncating to n bits.
extractWord :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SEval sym (SWord sym)
-- | Bitwise OR
wordOr :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Bitwise AND
wordAnd :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Bitwise XOR
wordXor :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Bitwise complement
wordComplement :: Backend sym => sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement addition of packed words. The arguments must have equal
-- bit width, and the result is of the same width. Overflow is silently
-- discarded.
wordPlus :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement subtraction of packed words. The arguments must have
-- equal bit width, and the result is of the same width. Overflow is
-- silently discarded.
wordMinus :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement multiplication of packed words. The arguments must have
-- equal bit width, and the result is of the same width. The high bits of
-- the multiplication are silently discarded.
wordMult :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement unsigned division of packed words. The arguments must
-- have equal bit width, and the result is of the same width. It is
-- illegal to call with a second argument concretely equal to 0.
wordDiv :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement unsigned modulus of packed words. The arguments must
-- have equal bit width, and the result is of the same width. It is
-- illegal to call with a second argument concretely equal to 0.
wordMod :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement signed division of packed words. The arguments must
-- have equal bit width, and the result is of the same width. It is
-- illegal to call with a second argument concretely equal to 0.
wordSignedDiv :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement signed modulus of packed words. The arguments must have
-- equal bit width, and the result is of the same width. It is illegal to
-- call with a second argument concretely equal to 0.
wordSignedMod :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Shift a bitvector left by the specified amount. The shift amount is
-- considered as an unsigned value. Shifting by more than the word length
-- results in 0.
wordShiftLeft :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Shift a bitvector right by the specified amount. This is a logical
-- shift, which shifts in 0 values on the left. The shift amount is
-- considered as an unsigned value. Shifting by more than the word length
-- results in 0.
wordShiftRight :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | Shift a bitvector right by the specified amount. This is an arithmetic
-- shift, which shifts in copies of the high bit on the left. The shift
-- amount is considered as an unsigned value. Shifting by more than the
-- word length results in filling the bitvector with the high bit.
wordSignedShiftRight :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
wordRotateLeft :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
wordRotateRight :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SWord sym)
-- | 2's complement negation of bitvectors
wordNegate :: Backend sym => sym -> SWord sym -> SEval sym (SWord sym)
-- | Compute rounded-up log-2 of the input
wordLg2 :: Backend sym => sym -> SWord sym -> SEval sym (SWord sym)
-- | Test if two words are equal. Arguments must have the same width.
wordEq :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SBit sym)
-- | Signed less-than comparison on words. Arguments must have the same
-- width.
wordSignedLessThan :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SBit sym)
-- | Unsigned less-than comparison on words. Arguments must have the same
-- width.
wordLessThan :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SBit sym)
-- | Unsigned greater-than comparison on words. Arguments must have the
-- same width.
wordGreaterThan :: Backend sym => sym -> SWord sym -> SWord sym -> SEval sym (SBit sym)
-- | Construct an integer value from the given packed word.
wordToInt :: Backend sym => sym -> SWord sym -> SEval sym (SInteger sym)
-- | Construct a signed integer value from the given packed word.
wordToSignedInt :: Backend sym => sym -> SWord sym -> SEval sym (SInteger sym)
-- | Addition of unbounded integers.
intPlus :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Negation of unbounded integers
intNegate :: Backend sym => sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Subtraction of unbounded integers.
intMinus :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Multiplication of unbounded integers.
intMult :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Integer division, rounding down. It is illegal to call with a second
-- argument concretely equal to 0. Same semantics as Haskell's
-- div operation.
intDiv :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Integer modulus, with division rounding down. It is illegal to call
-- with a second argument concretely equal to 0. Same semantics as
-- Haskell's mod operation.
intMod :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Equality comparison on integers
intEq :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SBit sym)
-- | Less-than comparison on integers
intLessThan :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SBit sym)
-- | Greater-than comparison on integers
intGreaterThan :: Backend sym => sym -> SInteger sym -> SInteger sym -> SEval sym (SBit sym)
-- | Turn an integer into a value in Z_n
intToZn :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SInteger sym)
-- | Transform a Z_n value into an integer, ensuring the value is properly
-- reduced modulo n
znToInt :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SInteger sym)
-- | Addition of integers modulo n, for a concrete positive integer n.
znPlus :: Backend sym => sym -> Integer -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Additive inverse of integers modulo n
znNegate :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SInteger sym)
-- | Subtraction of integers modulo n, for a concrete positive integer n.
znMinus :: Backend sym => sym -> Integer -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Multiplication of integers modulo n, for a concrete positive integer
-- n.
znMult :: Backend sym => sym -> Integer -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)
-- | Equality test of integers modulo n
znEq :: Backend sym => sym -> Integer -> SInteger sym -> SInteger sym -> SEval sym (SBit sym)
-- | Multiplicative inverse in (Z n). PRECONDITION: the modulus is a prime
znRecip :: Backend sym => sym -> Integer -> SInteger sym -> SEval sym (SInteger sym)
fpEq :: Backend sym => sym -> SFloat sym -> SFloat sym -> SEval sym (SBit sym)
fpLessThan :: Backend sym => sym -> SFloat sym -> SFloat sym -> SEval sym (SBit sym)
fpGreaterThan :: Backend sym => sym -> SFloat sym -> SFloat sym -> SEval sym (SBit sym)
fpLogicalEq :: Backend sym => sym -> SFloat sym -> SFloat sym -> SEval sym (SBit sym)
fpNaN :: Backend sym => sym -> Integer -> Integer -> SEval sym (SFloat sym)
fpPosInf :: Backend sym => sym -> Integer -> Integer -> SEval sym (SFloat sym)
fpPlus :: Backend sym => FPArith2 sym
fpMinus :: Backend sym => FPArith2 sym
fpMult :: Backend sym => FPArith2 sym
fpDiv :: Backend sym => FPArith2 sym
fpNeg :: Backend sym => sym -> SFloat sym -> SEval sym (SFloat sym)
fpAbs :: Backend sym => sym -> SFloat sym -> SEval sym (SFloat sym)
fpSqrt :: Backend sym => sym -> SWord sym -> SFloat sym -> SEval sym (SFloat sym)
fpFMA :: Backend sym => sym -> SWord sym -> SFloat sym -> SFloat sym -> SFloat sym -> SEval sym (SFloat sym)
fpIsZero :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsNeg :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsNaN :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsInf :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsNorm :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpIsSubnorm :: Backend sym => sym -> SFloat sym -> SEval sym (SBit sym)
fpToBits :: Backend sym => sym -> SFloat sym -> SEval sym (SWord sym)
fpFromBits :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SEval sym (SFloat sym)
fpToInteger :: Backend sym => sym -> String -> SWord sym -> SFloat sym -> SEval sym (SInteger sym)
fpFromInteger :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SInteger sym -> SEval sym (SFloat sym)
fpToRational :: Backend sym => sym -> SFloat sym -> SEval sym (SRational sym)
fpFromRational :: Backend sym => sym -> Integer -> Integer -> SWord sym -> SRational sym -> SEval sym (SFloat sym)
asciiMode :: PPOpts -> Integer -> Bool
-- | Some options for evalutaion
data EvalOpts
EvalOpts :: Logger -> PPOpts -> EvalOpts
-- | Where to print stuff (e.g., for trace)
[evalLogger] :: EvalOpts -> Logger
-- | How to pretty print things.
[evalPPOpts] :: EvalOpts -> PPOpts
-- | Create a packed word of n bits.
word :: Backend sym => sym -> Integer -> Integer -> SEval sym (GenValue sym)
-- | Construct a function value
lam :: Backend sym => sym -> (SEval sym (GenValue sym) -> SEval sym (GenValue sym)) -> SEval sym (GenValue sym)
-- | Functions that assume floating point inputs
flam :: Backend sym => sym -> (SFloat sym -> SEval sym (GenValue sym)) -> SEval sym (GenValue sym)
-- | A type lambda that expects a Type.
tlam :: Backend sym => sym -> (TValue -> SEval sym (GenValue sym)) -> SEval sym (GenValue sym)
-- | A type lambda that expects a Type of kind #.
nlam :: Backend sym => sym -> (Nat' -> SEval sym (GenValue sym)) -> SEval sym (GenValue sym)
-- | A type lambda that expects a finite numeric type.
ilam :: Backend sym => sym -> (Integer -> SEval sym (GenValue sym)) -> SEval sym (GenValue sym)
-- | Construct either a finite sequence, or a stream. In the finite case,
-- record whether or not the elements were bits, to aid pretty-printing.
mkSeq :: Backend sym => sym -> Nat' -> TValue -> SeqMap sym (GenValue sym) -> SEval sym (GenValue sym)
-- | Extract a bit value.
fromVBit :: GenValue sym -> SBit sym
-- | Extract an integer value.
fromVInteger :: GenValue sym -> SInteger sym
-- | Extract a rational value.
fromVRational :: GenValue sym -> SRational sym
fromVFloat :: GenValue sym -> SFloat sym
-- | Extract a finite sequence value.
fromVSeq :: GenValue sym -> SeqMap sym (GenValue sym)
-- | Extract a sequence.
fromSeq :: Backend sym => String -> GenValue sym -> SEval sym (SeqMap sym (GenValue sym))
fromWordVal :: Backend sym => String -> GenValue sym -> WordValue sym
asIndex :: Backend sym => sym -> String -> TValue -> GenValue sym -> Either (SInteger sym) (WordValue sym)
-- | Extract a packed word.
fromVWord :: Backend sym => sym -> String -> GenValue sym -> SEval sym (SWord sym)
vWordLen :: Backend sym => GenValue sym -> Maybe Integer
-- | If the given list of values are all fully-evaluated thunks containing
-- bits, return a packed word built from the same bits. However, if any
-- value is not a fully-evaluated bit, return Nothing.
tryFromBits :: Backend sym => sym -> [SEval sym (GenValue sym)] -> SEval sym (Maybe (SWord sym))
-- | Extract a function from a value.
fromVFun :: Backend sym => sym -> GenValue sym -> SEval sym (GenValue sym) -> SEval sym (GenValue sym)
-- | Extract a polymorphic function from a value.
fromVPoly :: Backend sym => sym -> GenValue sym -> TValue -> SEval sym (GenValue sym)
-- | Extract a polymorphic function from a value.
fromVNumPoly :: Backend sym => sym -> GenValue sym -> Nat' -> SEval sym (GenValue sym)
-- | Extract a tuple from a value.
fromVTuple :: GenValue sym -> [SEval sym (GenValue sym)]
-- | Extract a record from a value.
fromVRecord :: GenValue sym -> RecordMap Ident (SEval sym (GenValue sym))
-- | Lookup a field in a record.
lookupRecord :: Ident -> GenValue sym -> SEval sym (GenValue sym)
defaultPPOpts :: PPOpts
ppValue :: forall sym. Backend sym => sym -> PPOpts -> GenValue sym -> SEval sym Doc
iteValue :: Backend sym => sym -> SBit sym -> SEval sym (GenValue sym) -> SEval sym (GenValue sym) -> SEval sym (GenValue sym)
mergeValue :: Backend sym => sym -> SBit sym -> GenValue sym -> GenValue sym -> SEval sym (GenValue sym)
instance GHC.Generics.Generic (Cryptol.Eval.Value.GenValue sym)
instance GHC.Show.Show (Cryptol.Eval.Value.GenValue sym)
-- | This module generates random values for Cryptol types.
module Cryptol.Testing.Random
type Gen g x = Integer -> g -> (SEval x (GenValue x), g)
-- | A generator for values of the given type. This fails if we are given a
-- type that lacks a suitable random value generator.
randomValue :: (Backend sym, RandomGen g) => sym -> TValue -> Maybe (Gen g sym)
-- | Given a (function) type, compute generators for the function's
-- arguments.
dumpableType :: forall g. RandomGen g => TValue -> Maybe [Gen g Concrete]
-- | Given a (function) type, compute data necessary for random or
-- exhaustive testing.
--
-- The first returned component is a count of the number of possible
-- input test vectors, if the input types are finite. The second
-- component is a list of all the types of the function inputs. The third
-- component is a list of all input test vectors for exhaustive testing.
-- This will be empty unless the input types are finite. The final
-- argument is a list of generators for the inputs of the function.
--
-- This function will return Nothing if the input type does not
-- eventually return Bit, or if we cannot compute a generator
-- for one of the inputs.
testableType :: RandomGen g => TValue -> Maybe (Maybe Integer, [TValue], [[Value]], [Gen g Concrete])
-- | A test result is either a pass, a failure due to evaluating to
-- False, or a failure due to an exception raised during
-- evaluation
data TestResult
Pass :: TestResult
FailFalse :: [Value] -> TestResult
FailError :: EvalErrorEx -> [Value] -> TestResult
isPass :: TestResult -> Bool
-- | Return a collection of random tests.
returnTests :: RandomGen g => g -> [Gen g Concrete] -> Value -> Int -> IO [([Value], Value)]
exhaustiveTests :: MonadIO m => (Integer -> m ()) -> Value -> [[Value]] -> m (TestResult, Integer)
randomTests :: (MonadIO m, RandomGen g) => (Integer -> m ()) -> Integer -> Value -> [Gen g Concrete] -> g -> m (TestResult, Integer)
module Cryptol.Eval.Prims
-- | This type provides a lightweight syntactic framework for defining
-- Cryptol primitives. The main purpose of this type is to provide an
-- abstraction barrier that insulates the definitions of primitives from
-- possible changes in the representation of values.
data Prim sym
PFun :: (SEval sym (GenValue sym) -> Prim sym) -> Prim sym
PStrict :: (GenValue sym -> Prim sym) -> Prim sym
PWordFun :: (SWord sym -> Prim sym) -> Prim sym
PFloatFun :: (SFloat sym -> Prim sym) -> Prim sym
PTyPoly :: (TValue -> Prim sym) -> Prim sym
PNumPoly :: (Nat' -> Prim sym) -> Prim sym
PFinPoly :: (Integer -> Prim sym) -> Prim sym
PPrim :: SEval sym (GenValue sym) -> Prim sym
PVal :: GenValue sym -> Prim sym
-- | Evaluate a primitive into a value computation
evalPrim :: Backend sym => sym -> Name -> Prim sym -> SEval sym (GenValue sym)
module Cryptol.Eval.Env
data GenEvalEnv sym
EvalEnv :: !IntMap (Either (Prim sym) (SEval sym (GenValue sym))) -> !TypeEnv -> GenEvalEnv sym
[envVars] :: GenEvalEnv sym -> !IntMap (Either (Prim sym) (SEval sym (GenValue sym)))
[envTypes] :: GenEvalEnv sym -> !TypeEnv
ppEnv :: Backend sym => sym -> PPOpts -> GenEvalEnv sym -> SEval sym Doc
-- | Evaluation environment with no bindings
emptyEnv :: GenEvalEnv sym
-- | Bind a variable in the evaluation environment.
bindVar :: Backend sym => sym -> Name -> SEval sym (GenValue sym) -> GenEvalEnv sym -> SEval sym (GenEvalEnv sym)
-- | Bind a variable to a value in the evaluation environment, without
-- creating a thunk.
bindVarDirect :: Backend sym => Name -> Prim sym -> GenEvalEnv sym -> GenEvalEnv sym
-- | Lookup a variable in the environment.
lookupVar :: Name -> GenEvalEnv sym -> Maybe (Either (Prim sym) (SEval sym (GenValue sym)))
-- | Bind a type variable of kind *.
bindType :: TVar -> Either Nat' TValue -> GenEvalEnv sym -> GenEvalEnv sym
-- | Lookup a type variable.
lookupType :: TVar -> GenEvalEnv sym -> Maybe (Either Nat' TValue)
instance GHC.Generics.Generic (Cryptol.Eval.Env.GenEvalEnv sym)
instance GHC.Base.Semigroup (Cryptol.Eval.Env.GenEvalEnv sym)
instance GHC.Base.Monoid (Cryptol.Eval.Env.GenEvalEnv sym)
module Cryptol.Eval.Generic
-- | Make a numeric literal value at the given type.
mkLit :: Backend sym => sym -> TValue -> Integer -> SEval sym (GenValue sym)
-- | Make a numeric constant.
ecNumberV :: Backend sym => sym -> Prim sym
intV :: Backend sym => sym -> SInteger sym -> TValue -> SEval sym (GenValue sym)
ratioV :: Backend sym => sym -> Prim sym
ecFractionV :: Backend sym => sym -> Prim sym
fromZV :: Backend sym => sym -> Prim sym
type Binary sym = TValue -> GenValue sym -> GenValue sym -> SEval sym (GenValue sym)
binary :: Backend sym => Binary sym -> Prim sym
type Unary sym = TValue -> GenValue sym -> SEval sym (GenValue sym)
unary :: Backend sym => Unary sym -> Prim sym
type BinWord sym = Integer -> SWord sym -> SWord sym -> SEval sym (SWord sym)
ringBinary :: forall sym. Backend sym => sym -> BinWord sym -> (SInteger sym -> SInteger sym -> SEval sym (SInteger sym)) -> (Integer -> SInteger sym -> SInteger sym -> SEval sym (SInteger sym)) -> (SRational sym -> SRational sym -> SEval sym (SRational sym)) -> (SFloat sym -> SFloat sym -> SEval sym (SFloat sym)) -> Binary sym
type UnaryWord sym = Integer -> SWord sym -> SEval sym (SWord sym)
ringUnary :: forall sym. Backend sym => sym -> UnaryWord sym -> (SInteger sym -> SEval sym (SInteger sym)) -> (Integer -> SInteger sym -> SEval sym (SInteger sym)) -> (SRational sym -> SEval sym (SRational sym)) -> (SFloat sym -> SEval sym (SFloat sym)) -> Unary sym
ringNullary :: forall sym. Backend sym => sym -> (Integer -> SEval sym (SWord sym)) -> SEval sym (SInteger sym) -> (Integer -> SEval sym (SInteger sym)) -> SEval sym (SRational sym) -> (Integer -> Integer -> SEval sym (SFloat sym)) -> TValue -> SEval sym (GenValue sym)
integralBinary :: forall sym. Backend sym => sym -> BinWord sym -> (SInteger sym -> SInteger sym -> SEval sym (SInteger sym)) -> Binary sym
-- | Convert an unbounded integer to a value in Ring
fromIntegerV :: Backend sym => sym -> Prim sym
addV :: Backend sym => sym -> Binary sym
subV :: Backend sym => sym -> Binary sym
negateV :: Backend sym => sym -> Unary sym
mulV :: Backend sym => sym -> Binary sym
divV :: Backend sym => sym -> Binary sym
expV :: Backend sym => sym -> Prim sym
computeExponent :: Backend sym => sym -> TValue -> GenValue sym -> [SBit sym] -> SEval sym (GenValue sym)
modV :: Backend sym => sym -> Binary sym
-- | Convert a word to a non-negative integer.
toIntegerV :: Backend sym => sym -> Prim sym
recipV :: Backend sym => sym -> Prim sym
fieldDivideV :: Backend sym => sym -> Prim sym
roundOp :: Backend sym => sym -> String -> (SRational sym -> SEval sym (SInteger sym)) -> (SFloat sym -> SEval sym (SInteger sym)) -> Unary sym
floorV :: Backend sym => sym -> Unary sym
ceilingV :: Backend sym => sym -> Unary sym
truncV :: Backend sym => sym -> Unary sym
roundAwayV :: Backend sym => sym -> Unary sym
roundToEvenV :: Backend sym => sym -> Unary sym
andV :: Backend sym => sym -> Binary sym
orV :: Backend sym => sym -> Binary sym
xorV :: Backend sym => sym -> Binary sym
complementV :: Backend sym => sym -> Unary sym
lg2V :: Backend sym => sym -> Prim sym
sdivV :: Backend sym => sym -> Prim sym
smodV :: Backend sym => sym -> Prim sym
toSignedIntegerV :: Backend sym => sym -> Prim sym
cmpValue :: Backend sym => sym -> (SBit sym -> SBit sym -> SEval sym a -> SEval sym a) -> (SWord sym -> SWord sym -> SEval sym a -> SEval sym a) -> (SInteger sym -> SInteger sym -> SEval sym a -> SEval sym a) -> (Integer -> SInteger sym -> SInteger sym -> SEval sym a -> SEval sym a) -> (SRational sym -> SRational sym -> SEval sym a -> SEval sym a) -> (SFloat sym -> SFloat sym -> SEval sym a -> SEval sym a) -> TValue -> GenValue sym -> GenValue sym -> SEval sym a -> SEval sym a
bitLessThan :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
bitGreaterThan :: Backend sym => sym -> SBit sym -> SBit sym -> SEval sym (SBit sym)
valEq :: Backend sym => sym -> TValue -> GenValue sym -> GenValue sym -> SEval sym (SBit sym)
valLt :: Backend sym => sym -> TValue -> GenValue sym -> GenValue sym -> SBit sym -> SEval sym (SBit sym)
valGt :: Backend sym => sym -> TValue -> GenValue sym -> GenValue sym -> SBit sym -> SEval sym (SBit sym)
eqCombine :: Backend sym => sym -> SEval sym (SBit sym) -> SEval sym (SBit sym) -> SEval sym (SBit sym)
lexCombine :: Backend sym => sym -> SEval sym (SBit sym) -> SEval sym (SBit sym) -> SEval sym (SBit sym) -> SEval sym (SBit sym)
eqV :: Backend sym => sym -> Binary sym
distinctV :: Backend sym => sym -> Binary sym
lessThanV :: Backend sym => sym -> Binary sym
lessThanEqV :: Backend sym => sym -> Binary sym
greaterThanV :: Backend sym => sym -> Binary sym
greaterThanEqV :: Backend sym => sym -> Binary sym
signedLessThanV :: Backend sym => sym -> Binary sym
zeroV :: forall sym. Backend sym => sym -> TValue -> SEval sym (GenValue sym)
joinSeq :: Backend sym => sym -> Nat' -> Integer -> TValue -> SEval sym (SeqMap sym (GenValue sym)) -> SEval sym (GenValue sym)
-- | Join a sequence of sequences into a single sequence.
joinV :: Backend sym => sym -> Nat' -> Integer -> TValue -> SEval sym (GenValue sym) -> SEval sym (GenValue sym)
takeV :: Backend sym => sym -> Nat' -> Nat' -> TValue -> SEval sym (GenValue sym) -> SEval sym (GenValue sym)
dropV :: Backend sym => sym -> Integer -> Nat' -> TValue -> SEval sym (GenValue sym) -> SEval sym (GenValue sym)
-- | Split implementation.
splitV :: Backend sym => sym -> Nat' -> Integer -> TValue -> SEval sym (GenValue sym) -> SEval sym (GenValue sym)
reverseV :: forall sym. Backend sym => sym -> Integer -> TValue -> SEval sym (GenValue sym) -> SEval sym (GenValue sym)
transposeV :: Backend sym => sym -> Nat' -> Nat' -> TValue -> GenValue sym -> SEval sym (GenValue sym)
ccatV :: Backend sym => sym -> Integer -> Nat' -> TValue -> SEval sym (GenValue sym) -> SEval sym (GenValue sym) -> SEval sym (GenValue sym)
-- | Merge two values given a binop. This is used for and, or and xor.
logicBinary :: forall sym. Backend sym => sym -> (SBit sym -> SBit sym -> SEval sym (SBit sym)) -> (SWord sym -> SWord sym -> SEval sym (SWord sym)) -> Binary sym
logicUnary :: forall sym. Backend sym => sym -> (SBit sym -> SEval sym (SBit sym)) -> (SWord sym -> SEval sym (SWord sym)) -> Unary sym
assertIndexInBounds :: Backend sym => sym -> Nat' -> Either (SInteger sym) (WordValue sym) -> SEval sym ()
-- | Indexing operations.
indexPrim :: Backend sym => sym -> IndexDirection -> (Nat' -> TValue -> SeqMap sym (GenValue sym) -> TValue -> SInteger sym -> SEval sym (GenValue sym)) -> (Nat' -> TValue -> SeqMap sym (GenValue sym) -> TValue -> Integer -> [IndexSegment sym] -> SEval sym (GenValue sym)) -> Prim sym
updatePrim :: Backend sym => sym -> (Nat' -> TValue -> WordValue sym -> Either (SInteger sym) (WordValue sym) -> SEval sym (GenValue sym) -> SEval sym (WordValue sym)) -> (Nat' -> TValue -> SeqMap sym (GenValue sym) -> Either (SInteger sym) (WordValue sym) -> SEval sym (GenValue sym) -> SEval sym (SeqMap sym (GenValue sym))) -> Prim sym
fromToV :: Backend sym => sym -> Prim sym
fromThenToV :: Backend sym => sym -> Prim sym
fromToLessThanV :: Backend sym => sym -> Prim sym
fromToByV :: Backend sym => sym -> Prim sym
fromToByLessThanV :: Backend sym => sym -> Prim sym
fromToDownByV :: Backend sym => sym -> Prim sym
fromToDownByGreaterThanV :: Backend sym => sym -> Prim sym
infFromV :: Backend sym => sym -> Prim sym
infFromThenV :: Backend sym => sym -> Prim sym
shiftLeftReindex :: Nat' -> Integer -> Integer -> Maybe Integer
shiftRightReindex :: Nat' -> Integer -> Integer -> Maybe Integer
rotateLeftReindex :: Nat' -> Integer -> Integer -> Maybe Integer
rotateRightReindex :: Nat' -> Integer -> Integer -> Maybe Integer
-- | Generic implementation of shifting. Uses the provided word-level
-- operation to perform the shift, when possible. Otherwise falls back on
-- a barrel shifter that uses the provided reindexing operation to
-- implement the concrete shifting operations. The reindex operation is
-- given the size of the sequence, the requested index value for the new
-- output sequence, and the amount to shift. The return value is an index
-- into the original sequence if in bounds, and Nothing otherwise.
logicShift :: Backend sym => sym -> String -> (sym -> Nat' -> TValue -> SInteger sym -> SEval sym (SInteger sym)) -> (SWord sym -> SWord sym -> SEval sym (SWord sym)) -> (SWord sym -> SWord sym -> SEval sym (SWord sym)) -> (Nat' -> Integer -> Integer -> Maybe Integer) -> (Nat' -> Integer -> Integer -> Maybe Integer) -> Prim sym
intShifter :: Backend sym => sym -> String -> (SWord sym -> SWord sym -> SEval sym (SWord sym)) -> (Nat' -> Integer -> Integer -> Maybe Integer) -> Nat' -> TValue -> GenValue sym -> SInteger sym -> SEval sym (GenValue sym)
wordShifter :: Backend sym => sym -> String -> (SWord sym -> SWord sym -> SEval sym (SWord sym)) -> (Nat' -> Integer -> Integer -> Maybe Integer) -> Nat' -> TValue -> GenValue sym -> WordValue sym -> SEval sym (GenValue sym)
shiftShrink :: Backend sym => sym -> Nat' -> TValue -> SInteger sym -> SEval sym (SInteger sym)
rotateShrink :: Backend sym => sym -> Nat' -> TValue -> SInteger sym -> SEval sym (SInteger sym)
sshrV :: Backend sym => sym -> Prim sym
errorV :: forall sym. Backend sym => sym -> TValue -> String -> SEval sym (GenValue sym)
-- | Expect a word value. Mask it to an 8-bits ASCII value and return the
-- associated character, if it is concrete. Otherwise, return a
-- ? character
valueToChar :: Backend sym => sym -> GenValue sym -> SEval sym Char
valueToString :: Backend sym => sym -> GenValue sym -> SEval sym String
foldlV :: Backend sym => sym -> Prim sym
foldl'V :: Backend sym => sym -> Prim sym
scanlV :: forall sym. Backend sym => sym -> Prim sym
-- | Produce a random value with the given seed. If we do not support
-- making values of the given type, return zero of that type. TODO: do
-- better than returning zero
randomV :: Backend sym => sym -> TValue -> Integer -> SEval sym (GenValue sym)
parmapV :: Backend sym => sym -> Prim sym
sparkParMap :: Backend sym => sym -> (SEval sym a -> SEval sym (GenValue sym)) -> Integer -> SeqMap sym a -> SEval sym (SeqMap sym (GenValue sym))
-- | A helper for definitng floating point constants.
fpConst :: Backend sym => (Integer -> Integer -> SEval sym (SFloat sym)) -> Prim sym
-- | Make a Cryptol value for a binary arithmetic function.
fpBinArithV :: Backend sym => sym -> FPArith2 sym -> Prim sym
-- | Rounding mode used in FP operations that do not specify it explicitly.
fpRndMode :: Backend sym => sym -> SEval sym (SWord sym)
-- | Rounding mode used in FP operations that do not specify it explicitly.
fpRndRNE :: Backend sym => sym -> SEval sym (SWord sym)
-- | Rounding mode used in FP operations that do not specify it explicitly.
fpRndRNA :: Backend sym => sym -> SEval sym (SWord sym)
-- | Rounding mode used in FP operations that do not specify it explicitly.
fpRndRTP :: Backend sym => sym -> SEval sym (SWord sym)
-- | Rounding mode used in FP operations that do not specify it explicitly.
fpRndRTN :: Backend sym => sym -> SEval sym (SWord sym)
-- | Rounding mode used in FP operations that do not specify it explicitly.
fpRndRTZ :: Backend sym => sym -> SEval sym (SWord sym)
genericFloatTable :: Backend sym => sym -> Map PrimIdent (Prim sym)
genericPrimTable :: Backend sym => sym -> IO EvalOpts -> Map PrimIdent (Prim sym)
module Cryptol.Eval.What4
type Value sym = GenValue (What4 sym)
primTable :: IsSymExprBuilder sym => What4 sym -> IO EvalOpts -> Map PrimIdent (Prim (What4 sym))
module Cryptol.Eval.Concrete
type Value = GenValue Concrete
primTable :: IO EvalOpts -> Map PrimIdent (Prim Concrete)
-- | Given an expected type, returns an expression that evaluates to this
-- value, if we can determine it.
toExpr :: PrimMap -> TValue -> Value -> Eval (Maybe Expr)
module Cryptol.Symbolic
data ProverCommand
ProverCommand :: QueryType -> String -> Bool -> Bool -> !IORef ProverStats -> [DeclGroup] -> Maybe FilePath -> Expr -> Schema -> Bool -> ProverCommand
-- | The type of query to run
[pcQueryType] :: ProverCommand -> QueryType
-- | Which prover to use (one of the strings in proverConfigs)
[pcProverName] :: ProverCommand -> String
-- | Verbosity flag passed to SBV
[pcVerbose] :: ProverCommand -> Bool
-- | Model validation flag passed to SBV
[pcValidate] :: ProverCommand -> Bool
-- | Record timing information here
[pcProverStats] :: ProverCommand -> !IORef ProverStats
-- | Extra declarations to bring into scope for symbolic simulation
[pcExtraDecls] :: ProverCommand -> [DeclGroup]
-- | Optionally output the SMTLIB query to a file
[pcSmtFile] :: ProverCommand -> Maybe FilePath
-- | The typechecked expression to evaluate
[pcExpr] :: ProverCommand -> Expr
-- | The Schema of pcExpr
[pcSchema] :: ProverCommand -> Schema
-- | Should we ignore safety predicates?
[pcIgnoreSafety] :: ProverCommand -> Bool
data QueryType
SatQuery :: SatNum -> QueryType
ProveQuery :: QueryType
SafetyQuery :: QueryType
data SatNum
AllSat :: SatNum
SomeSat :: Int -> SatNum
-- | A prover result is either an error message, an empty result (eg for
-- the offline prover), a counterexample or a lazy list of satisfying
-- assignments.
data ProverResult
AllSatResult :: [SatResult] -> ProverResult
ThmResult :: [TValue] -> ProverResult
CounterExample :: CounterExampleType -> SatResult -> ProverResult
EmptyResult :: ProverResult
ProverError :: String -> ProverResult
type ProverStats = NominalDiffTime
-- | A :prove command can fail either because some input causes
-- the predicate to violate a safety assertion, or because the predicate
-- returns false for some input.
data CounterExampleType
SafetyViolation :: CounterExampleType
PredicateFalsified :: CounterExampleType
data FinType
FTBit :: FinType
FTInteger :: FinType
FTIntMod :: Integer -> FinType
FTRational :: FinType
FTFloat :: Integer -> Integer -> FinType
FTSeq :: Integer -> FinType -> FinType
FTTuple :: [FinType] -> FinType
FTRecord :: RecordMap Ident FinType -> FinType
FTNewtype :: Newtype -> [Either Nat' TValue] -> RecordMap Ident FinType -> FinType
finType :: TValue -> Maybe FinType
unFinType :: FinType -> TValue
predArgTypes :: QueryType -> Schema -> Either String [FinType]
data VarShape sym
VarBit :: SBit sym -> VarShape sym
VarInteger :: SInteger sym -> VarShape sym
VarRational :: SInteger sym -> SInteger sym -> VarShape sym
VarFloat :: SFloat sym -> VarShape sym
VarWord :: SWord sym -> VarShape sym
VarFinSeq :: Integer -> [VarShape sym] -> VarShape sym
VarTuple :: [VarShape sym] -> VarShape sym
VarRecord :: RecordMap Ident (VarShape sym) -> VarShape sym
varShapeToValue :: Backend sym => sym -> VarShape sym -> GenValue sym
freshVar :: Backend sym => FreshVarFns sym -> FinType -> IO (VarShape sym)
computeModel :: PrimMap -> [FinType] -> [VarShape Concrete] -> [(TValue, Expr, Value)]
data FreshVarFns sym
FreshVarFns :: IO (SBit sym) -> (Integer -> IO (SWord sym)) -> (Maybe Integer -> Maybe Integer -> IO (SInteger sym)) -> (Integer -> Integer -> IO (SFloat sym)) -> FreshVarFns sym
[freshBitVar] :: FreshVarFns sym -> IO (SBit sym)
[freshWordVar] :: FreshVarFns sym -> Integer -> IO (SWord sym)
[freshIntegerVar] :: FreshVarFns sym -> Maybe Integer -> Maybe Integer -> IO (SInteger sym)
[freshFloatVar] :: FreshVarFns sym -> Integer -> Integer -> IO (SFloat sym)
modelPred :: Backend sym => sym -> [VarShape sym] -> [VarShape Concrete] -> SEval sym (SBit sym)
varModelPred :: Backend sym => sym -> (VarShape sym, VarShape Concrete) -> SEval sym (SBit sym)
varToExpr :: PrimMap -> FinType -> VarShape Concrete -> Expr
flattenShape :: VarShape sym -> [VarShape sym] -> [VarShape sym]
-- | Flatten structured shapes (like tuples and sequences), leaving only a
-- sequence of variable shapes of base type.
flattenShapes :: [VarShape sym] -> [VarShape sym] -> [VarShape sym]
instance GHC.Show.Show Cryptol.Symbolic.SatNum
instance GHC.Show.Show Cryptol.Symbolic.QueryType
module Cryptol.Eval
-- | Extend the given evaluation environment with all the declarations
-- contained in the given module.
moduleEnv :: EvalPrims sym => sym -> Module -> GenEvalEnv sym -> SEval sym (GenEvalEnv sym)
-- | Execute the given evaluation action.
runEval :: CallStack -> Eval a -> IO a
-- | Some options for evalutaion
data EvalOpts
EvalOpts :: Logger -> PPOpts -> EvalOpts
-- | Where to print stuff (e.g., for trace)
[evalLogger] :: EvalOpts -> Logger
-- | How to pretty print things.
[evalPPOpts] :: EvalOpts -> PPOpts
-- | How to pretty print things when evaluating
data PPOpts
PPOpts :: Bool -> Int -> Int -> Int -> PPFloatFormat -> FieldOrder -> PPOpts
[useAscii] :: PPOpts -> Bool
[useBase] :: PPOpts -> Int
[useInfLength] :: PPOpts -> Int
[useFPBase] :: PPOpts -> Int
[useFPFormat] :: PPOpts -> PPFloatFormat
[useFieldOrder] :: PPOpts -> FieldOrder
defaultPPOpts :: PPOpts
-- | The monad for Cryptol evaluation. A computation is either "ready",
-- which means it represents only trivial computation, or is an "eval"
-- action which must be computed to get the answer, or it is a "thunk",
-- which represents a delayed, shared computation.
data Eval a
type EvalEnv = GenEvalEnv Concrete
-- | Evaluation environment with no bindings
emptyEnv :: GenEvalEnv sym
-- | Evaluate a Cryptol expression to a value. This evaluator is
-- parameterized by the EvalPrims class, which defines the
-- behavior of bits and words, in addition to providing implementations
-- for all the primitives.
evalExpr :: (?range :: Range, EvalPrims sym) => sym -> GenEvalEnv sym -> Expr -> SEval sym (GenValue sym)
-- | Extend the given evaluation environment with the result of evaluating
-- the given collection of declaration groups.
evalDecls :: EvalPrims sym => sym -> [DeclGroup] -> GenEvalEnv sym -> SEval sym (GenEvalEnv sym)
evalNewtypeDecls :: EvalPrims sym => sym -> Map Name Newtype -> GenEvalEnv sym -> SEval sym (GenEvalEnv sym)
-- | Apply the the given "selector" form to the given value. Note that
-- selectors are expected to apply only to values of the right type, e.g.
-- tuple selectors expect only tuple values. The lifting of tuple an
-- record selectors over functions and sequences has already been
-- resolved earlier in the typechecker.
evalSel :: Backend sym => sym -> GenValue sym -> Selector -> SEval sym (GenValue sym)
evalSetSel :: forall sym. Backend sym => sym -> TValue -> GenValue sym -> Selector -> SEval sym (GenValue sym) -> SEval sym (GenValue sym)
-- | Data type describing errors that can occur during evaluation.
data EvalError
-- | Out-of-bounds index
InvalidIndex :: Maybe Integer -> EvalError
-- | Division or modulus by 0
DivideByZero :: EvalError
-- | Exponentiation by negative integer
NegativeExponent :: EvalError
-- | Logarithm of a negative integer
LogNegative :: EvalError
-- | Call to the Cryptol error primitive
UserError :: String -> EvalError
-- | Detectable nontermination
LoopError :: String -> EvalError
-- | Primitive with no implementation
NoPrim :: Name -> EvalError
-- | Invalid rounding mode
BadRoundingMode :: Integer -> EvalError
-- | Value outside the domain of a partial function.
BadValue :: String -> EvalError
data EvalErrorEx
EvalErrorEx :: CallStack -> EvalError -> EvalErrorEx
data Unsupported
-- | Operation cannot be supported in the symbolic simulator
UnsupportedSymbolicOp :: String -> Unsupported
data WordTooWide
-- | Bitvector too large
WordTooWide :: Integer -> WordTooWide
-- | Force the evaluation of a value
forceValue :: Backend sym => GenValue sym -> SEval sym ()
instance GHC.Base.Semigroup (Cryptol.Eval.ListEnv sym)
instance GHC.Base.Monoid (Cryptol.Eval.ListEnv sym)
module Cryptol.ModuleSystem.Env
-- | This is the current state of the interpreter.
data ModuleEnv
ModuleEnv :: LoadedModules -> NameSeeds -> EvalEnv -> CoreLint -> !Bool -> Maybe ModName -> [FilePath] -> DynamicEnv -> !Supply -> ModuleEnv
-- | Information about all loaded modules. See LoadedModule.
-- Contains information such as the file where the module was loaded
-- from, as well as the module's interface, used for type checking.
[meLoadedModules] :: ModuleEnv -> LoadedModules
-- | A source of new names for the type checker.
[meNameSeeds] :: ModuleEnv -> NameSeeds
-- | The evaluation environment. Contains the values for all loaded
-- modules, both public and private.
[meEvalEnv] :: ModuleEnv -> EvalEnv
-- | Should we run the linter to ensure sanity.
[meCoreLint] :: ModuleEnv -> CoreLint
-- | Are we assuming that local bindings are monomorphic. XXX: We should
-- probably remove this flag, and set it to True.
[meMonoBinds] :: ModuleEnv -> !Bool
-- | The "current" module. Used to decide how to print names, for example.
[meFocusedModule] :: ModuleEnv -> Maybe ModName
-- | Where we look for things.
[meSearchPath] :: ModuleEnv -> [FilePath]
-- | This contains additional definitions that were made at the command
-- line, and so they don't reside in any module.
[meDynEnv] :: ModuleEnv -> DynamicEnv
-- | Name source for the renamer
[meSupply] :: ModuleEnv -> !Supply
-- | Should we run the linter?
data CoreLint
-- | Don't run core lint
NoCoreLint :: CoreLint
-- | Run core lint
CoreLint :: CoreLint
resetModuleEnv :: ModuleEnv -> ModuleEnv
initialModuleEnv :: IO ModuleEnv
-- | Try to focus a loaded module in the module environment.
focusModule :: ModName -> ModuleEnv -> Maybe ModuleEnv
-- | Get a list of all the loaded modules. Each module in the resulting
-- list depends only on other modules that precede it. Note that this
-- includes parameterized modules.
loadedModules :: ModuleEnv -> [Module]
-- | Get a list of all the loaded non-parameterized modules. These are the
-- modules that can be used for evaluation, proving etc.
loadedNonParamModules :: ModuleEnv -> [Module]
loadedNewtypes :: ModuleEnv -> Map Name IfaceNewtype
-- | Are any parameterized modules loaded?
hasParamModules :: ModuleEnv -> Bool
allDeclGroups :: ModuleEnv -> [DeclGroup]
-- | Contains enough information to browse what's in scope, or type check
-- new expressions.
data ModContext
ModContext :: IfaceParams -> Set Name -> IfaceDecls -> NamingEnv -> NameDisp -> ModContext
[mctxParams] :: ModContext -> IfaceParams
[mctxExported] :: ModContext -> Set Name
-- | Should contain at least names in NamingEnv, but may have more
[mctxDecls] :: ModContext -> IfaceDecls
-- | What's in scope inside the module
[mctxNames] :: ModContext -> NamingEnv
[mctxNameDisp] :: ModContext -> NameDisp
modContextOf :: ModName -> ModuleEnv -> Maybe ModContext
dynModContext :: ModuleEnv -> ModContext
-- | Given the state of the environment, compute information about what's
-- in scope on the REPL. This includes what's in the focused module, plus
-- any additional definitions from the REPL (e.g., let bound names, and
-- it).
focusedEnv :: ModuleEnv -> ModContext
-- | The location of a module
data ModulePath
InFile :: FilePath -> ModulePath
-- | Label, content
InMem :: String -> ByteString -> ModulePath
-- | The name of the content---either the file path, or the provided label.
modulePathLabel :: ModulePath -> String
data LoadedModules
LoadedModules :: [LoadedModule] -> [LoadedModule] -> LoadedModules
-- | Invariants: 1) All the dependencies of any module m must
-- precede m in the list. 2) Does not contain any parameterized
-- modules.
[lmLoadedModules] :: LoadedModules -> [LoadedModule]
-- | Loaded parameterized modules.
[lmLoadedParamModules] :: LoadedModules -> [LoadedModule]
getLoadedModules :: LoadedModules -> [LoadedModule]
data LoadedModule
LoadedModule :: ModName -> ModulePath -> String -> !NamingEnv -> Iface -> Module -> Fingerprint -> LoadedModule
-- | The name of this module. Should match what's in lmModule
[lmName] :: LoadedModule -> ModName
-- | The file path used to load this module (may not be canonical)
[lmFilePath] :: LoadedModule -> ModulePath
-- | An identifier used to identify the source of the bytes for the module.
-- For files we just use the cononical path, for in memory things we use
-- their label.
[lmModuleId] :: LoadedModule -> String
-- | What's in scope in this module
[lmNamingEnv] :: LoadedModule -> !NamingEnv
-- | The module's interface.
[lmInterface] :: LoadedModule -> Iface
-- | The actual type-checked module
[lmModule] :: LoadedModule -> Module
[lmFingerprint] :: LoadedModule -> Fingerprint
-- | Has this module been loaded already.
isLoaded :: ModName -> LoadedModules -> Bool
-- | Is this a loaded parameterized module.
isLoadedParamMod :: ModName -> LoadedModules -> Bool
-- | Try to find a previously loaded module
lookupModule :: ModName -> ModuleEnv -> Maybe LoadedModule
-- | Add a freshly loaded module. If it was previously loaded, then the new
-- version is ignored.
addLoadedModule :: ModulePath -> String -> Fingerprint -> NamingEnv -> Module -> LoadedModules -> LoadedModules
-- | Remove a previously loaded module. Note that this removes exactly the
-- modules specified by the predicate. One should be carfule to preserve
-- the invariant on LoadedModules.
removeLoadedModule :: (LoadedModule -> Bool) -> LoadedModules -> LoadedModules
-- | Extra information we need to carry around to dynamically extend an
-- environment outside the context of a single module. Particularly
-- useful when dealing with interactive declarations as in let
-- or it.
data DynamicEnv
DEnv :: NamingEnv -> [DeclGroup] -> Map Name TySyn -> EvalEnv -> DynamicEnv
[deNames] :: DynamicEnv -> NamingEnv
[deDecls] :: DynamicEnv -> [DeclGroup]
[deTySyns] :: DynamicEnv -> Map Name TySyn
[deEnv] :: DynamicEnv -> EvalEnv
-- | Build IfaceDecls that correspond to all of the bindings in the
-- dynamic environment.
--
-- XXX: if we add newtypes, etc. at the REPL, revisit this.
deIfaceDecls :: DynamicEnv -> IfaceDecls
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Env.CoreLint
instance GHC.Generics.Generic Cryptol.ModuleSystem.Env.CoreLint
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Env.ModulePath
instance GHC.Generics.Generic Cryptol.ModuleSystem.Env.ModulePath
instance GHC.Show.Show Cryptol.ModuleSystem.Env.ModulePath
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Env.LoadedModule
instance GHC.Generics.Generic Cryptol.ModuleSystem.Env.LoadedModule
instance GHC.Show.Show Cryptol.ModuleSystem.Env.LoadedModule
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Env.LoadedModules
instance GHC.Generics.Generic Cryptol.ModuleSystem.Env.LoadedModules
instance GHC.Show.Show Cryptol.ModuleSystem.Env.LoadedModules
instance GHC.Generics.Generic Cryptol.ModuleSystem.Env.DynamicEnv
instance GHC.Generics.Generic Cryptol.ModuleSystem.Env.ModuleEnv
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Env.ModuleEnv
instance GHC.Base.Semigroup Cryptol.ModuleSystem.Env.DynamicEnv
instance GHC.Base.Monoid Cryptol.ModuleSystem.Env.DynamicEnv
instance GHC.Base.Semigroup Cryptol.ModuleSystem.Env.LoadedModules
instance GHC.Base.Monoid Cryptol.ModuleSystem.Env.LoadedModules
instance GHC.Classes.Eq Cryptol.ModuleSystem.Env.ModulePath
instance Cryptol.Utils.PP.PP Cryptol.ModuleSystem.Env.ModulePath
instance GHC.Base.Semigroup Cryptol.ModuleSystem.Env.ModContext
instance GHC.Base.Monoid Cryptol.ModuleSystem.Env.ModContext
module Cryptol.REPL.Browse
data BrowseHow
BrowseExported :: BrowseHow
BrowseInScope :: BrowseHow
browseModContext :: BrowseHow -> ModContext -> Doc Void
module Cryptol.Backend.SBV
data SBV
SBV :: MVar State -> MVar SVal -> SBV
[sbvStateVar] :: SBV -> MVar State
[sbvDefRelations] :: SBV -> MVar SVal
newtype SBVEval a
SBVEval :: Eval (SBVResult a) -> SBVEval a
[sbvEval] :: SBVEval a -> Eval (SBVResult a)
data SBVResult a
SBVError :: !EvalErrorEx -> SBVResult a
SBVResult :: !SVal -> !a -> SBVResult a
literalSWord :: Int -> Integer -> SWord SBV
freshSBool_ :: SBV -> IO (SBit SBV)
freshBV_ :: SBV -> Int -> IO (SWord SBV)
freshSInteger_ :: SBV -> IO (SInteger SBV)
addDefEqn :: SBV -> SVal -> IO ()
ashr :: SVal -> SVal -> SVal
lshr :: SVal -> SVal -> SVal
shl :: SVal -> SVal -> SVal
evalPanic :: String -> [String] -> a
svFromInteger :: Integer -> SInteger SBV -> SWord SBV
svToInteger :: SWord SBV -> SInteger SBV
instance GHC.Base.Functor Cryptol.Backend.SBV.SBVEval
instance GHC.Base.Applicative Cryptol.Backend.SBV.SBVEval
instance GHC.Base.Monad Cryptol.Backend.SBV.SBVEval
instance Control.Monad.IO.Class.MonadIO Cryptol.Backend.SBV.SBVEval
instance Cryptol.Backend.Backend Cryptol.Backend.SBV.SBV
instance GHC.Base.Functor Cryptol.Backend.SBV.SBVResult
instance GHC.Base.Applicative Cryptol.Backend.SBV.SBVResult
instance GHC.Base.Monad Cryptol.Backend.SBV.SBVResult
module Cryptol.Eval.SBV
primTable :: SBV -> IO EvalOpts -> Map PrimIdent (Prim SBV)
module Cryptol.Version
commitHash :: String
commitShortHash :: String
commitBranch :: String
commitDirty :: Bool
version :: Version
displayVersion :: Monad m => (String -> m ()) -> m ()
module Cryptol.Parser
parseModule :: Config -> Text -> Either ParseError (Module PName)
parseProgram :: Layout -> Text -> Either ParseError (Program PName)
parseProgramWith :: Config -> Text -> Either ParseError (Program PName)
parseExpr :: Text -> Either ParseError (Expr PName)
parseExprWith :: Config -> Text -> Either ParseError (Expr PName)
parseDecl :: Text -> Either ParseError (Decl PName)
parseDeclWith :: Config -> Text -> Either ParseError (Decl PName)
parseDecls :: Text -> Either ParseError [Decl PName]
parseDeclsWith :: Config -> Text -> Either ParseError [Decl PName]
parseLetDecl :: Text -> Either ParseError (Decl PName)
parseLetDeclWith :: Config -> Text -> Either ParseError (Decl PName)
parseRepl :: Text -> Either ParseError (ReplInput PName)
parseReplWith :: Config -> Text -> Either ParseError (ReplInput PName)
parseSchema :: Text -> Either ParseError (Schema PName)
parseSchemaWith :: Config -> Text -> Either ParseError (Schema PName)
parseModName :: String -> Maybe ModName
parseHelpName :: String -> Maybe PName
data ParseError
HappyError :: FilePath -> Located Token -> ParseError
HappyErrorMsg :: Range -> [String] -> ParseError
HappyUnexpected :: FilePath -> Maybe (Located Token) -> String -> ParseError
HappyOutOfTokens :: FilePath -> Position -> ParseError
ppError :: ParseError -> Doc
data Layout
Layout :: Layout
NoLayout :: Layout
data Config
Config :: !FilePath -> !Position -> !Layout -> PreProc -> [FilePath] -> Bool -> Config
-- | File that we are working on
[cfgSource] :: Config -> !FilePath
-- | Starting position for the parser
[cfgStart] :: Config -> !Position
-- | Settings for layout processing
[cfgLayout] :: Config -> !Layout
-- | Preprocessor settings
[cfgPreProc] :: Config -> PreProc
-- | Implicit includes
[cfgAutoInclude] :: Config -> [FilePath]
-- | When we do layout processing should we add a vCurly (i.e., are we
-- parsing a list of things).
[cfgModuleScope] :: Config -> Bool
defaultConfig :: Config
guessPreProc :: FilePath -> PreProc
data PreProc
None :: PreProc
Markdown :: PreProc
LaTeX :: PreProc
module Cryptol.Parser.NoInclude
removeIncludesModule :: (FilePath -> IO ByteString) -> FilePath -> Module PName -> IO (Either [IncludeError] (Module PName))
data IncludeError
IncludeFailed :: Located FilePath -> IncludeError
IncludeDecodeFailed :: Located FilePath -> UnicodeException -> IncludeError
IncludeParseError :: ParseError -> IncludeError
IncludeCycle :: [Located FilePath] -> IncludeError
ppIncludeError :: IncludeError -> Doc
instance Control.DeepSeq.NFData Cryptol.Parser.NoInclude.IncludeError
instance GHC.Generics.Generic Cryptol.Parser.NoInclude.IncludeError
instance GHC.Show.Show Cryptol.Parser.NoInclude.IncludeError
instance GHC.Base.Functor Cryptol.Parser.NoInclude.NoIncM
instance GHC.Base.Applicative Cryptol.Parser.NoInclude.NoIncM
instance GHC.Base.Monad Cryptol.Parser.NoInclude.NoIncM
instance Control.Monad.Fail.MonadFail Cryptol.Parser.NoInclude.NoIncM
module Cryptol.ModuleSystem.Monad
data ImportSource
FromModule :: ModName -> ImportSource
FromImport :: Located Import -> ImportSource
FromModuleInstance :: Located ModName -> ImportSource
importedModule :: ImportSource -> ModName
data ModuleError
-- | Unable to find the module given, tried looking in these paths
ModuleNotFound :: ModName -> [FilePath] -> ModuleError
-- | Unable to open a file
CantFindFile :: FilePath -> ModuleError
-- | Bad UTF-8 encoding in while decoding this file
BadUtf8 :: ModulePath -> UnicodeException -> ModuleError
-- | Some other IO error occurred while reading this file
OtherIOError :: FilePath -> IOException -> ModuleError
-- | Generated this parse error when parsing the file for module m
ModuleParseError :: ModulePath -> ParseError -> ModuleError
-- | Recursive module group discovered
RecursiveModules :: [ImportSource] -> ModuleError
-- | Problems during the renaming phase
RenamerErrors :: ImportSource -> [RenamerError] -> ModuleError
-- | Problems during the NoPat phase
NoPatErrors :: ImportSource -> [Error] -> ModuleError
-- | Problems during the NoInclude phase
NoIncludeErrors :: ImportSource -> [IncludeError] -> ModuleError
-- | Problems during type checking
TypeCheckingFailed :: ImportSource -> NameMap -> [(Range, Error)] -> ModuleError
-- | Problems after type checking, eg. specialization
OtherFailure :: String -> ModuleError
-- | Module loaded by 'import' statement has the wrong module name
ModuleNameMismatch :: ModName -> Located ModName -> ModuleError
-- | Two modules loaded from different files have the same module name
DuplicateModuleName :: ModName -> FilePath -> FilePath -> ModuleError
-- | Attempt to import a parametrized module that was not instantiated.
ImportedParamModule :: ModName -> ModuleError
-- | Failed to add the module parameters to all definitions in a module.
FailedToParameterizeModDefs :: ModName -> [Name] -> ModuleError
NotAParameterizedModule :: ModName -> ModuleError
-- | This is just a tag on the error, indicating the file containing it. It
-- is convenient when we had to look for the module, and we'd like to
-- communicate the location of pthe problematic module to the handler.
ErrorInFile :: ModulePath -> ModuleError -> ModuleError
moduleNotFound :: ModName -> [FilePath] -> ModuleM a
cantFindFile :: FilePath -> ModuleM a
badUtf8 :: ModulePath -> UnicodeException -> ModuleM a
otherIOError :: FilePath -> IOException -> ModuleM a
moduleParseError :: ModulePath -> ParseError -> ModuleM a
recursiveModules :: [ImportSource] -> ModuleM a
renamerErrors :: [RenamerError] -> ModuleM a
noPatErrors :: [Error] -> ModuleM a
noIncludeErrors :: [IncludeError] -> ModuleM a
typeCheckingFailed :: NameMap -> [(Range, Error)] -> ModuleM a
moduleNameMismatch :: ModName -> Located ModName -> ModuleM a
duplicateModuleName :: ModName -> FilePath -> FilePath -> ModuleM a
importParamModule :: ModName -> ModuleM a
failedToParameterizeModDefs :: ModName -> [Name] -> ModuleM a
notAParameterizedModule :: ModName -> ModuleM a
-- | Run the computation, and if it caused and error, tag the error with
-- the given file.
errorInFile :: ModulePath -> ModuleM a -> ModuleM a
data ModuleWarning
TypeCheckWarnings :: NameMap -> [(Range, Warning)] -> ModuleWarning
RenamerWarnings :: [RenamerWarning] -> ModuleWarning
warn :: [ModuleWarning] -> ModuleM ()
typeCheckWarnings :: NameMap -> [(Range, Warning)] -> ModuleM ()
renamerWarnings :: [RenamerWarning] -> ModuleM ()
data RO m
RO :: [ImportSource] -> m EvalOpts -> Bool -> (FilePath -> m ByteString) -> Solver -> RO m
[roLoading] :: RO m -> [ImportSource]
[roEvalOpts] :: RO m -> m EvalOpts
[roCallStacks] :: RO m -> Bool
[roFileReader] :: RO m -> FilePath -> m ByteString
[roTCSolver] :: RO m -> Solver
emptyRO :: ModuleInput m -> RO m
newtype ModuleT m a
ModuleT :: ReaderT (RO m) (StateT ModuleEnv (ExceptionT ModuleError (WriterT [ModuleWarning] m))) a -> ModuleT m a
[unModuleT] :: ModuleT m a -> ReaderT (RO m) (StateT ModuleEnv (ExceptionT ModuleError (WriterT [ModuleWarning] m))) a
data ModuleInput m
ModuleInput :: Bool -> m EvalOpts -> (FilePath -> m ByteString) -> ModuleEnv -> Solver -> ModuleInput m
[minpCallStacks] :: ModuleInput m -> Bool
[minpEvalOpts] :: ModuleInput m -> m EvalOpts
[minpByteReader] :: ModuleInput m -> FilePath -> m ByteString
[minpModuleEnv] :: ModuleInput m -> ModuleEnv
[minpTCSolver] :: ModuleInput m -> Solver
runModuleT :: Monad m => ModuleInput m -> ModuleT m a -> m (Either ModuleError (a, ModuleEnv), [ModuleWarning])
type ModuleM = ModuleT IO
runModuleM :: ModuleInput IO -> ModuleM a -> IO (Either ModuleError (a, ModuleEnv), [ModuleWarning])
io :: BaseM m IO => IO a -> ModuleT m a
getByteReader :: Monad m => ModuleT m (FilePath -> m ByteString)
getCallStacks :: Monad m => ModuleT m Bool
readBytes :: Monad m => FilePath -> ModuleT m ByteString
getModuleEnv :: Monad m => ModuleT m ModuleEnv
getTCSolver :: Monad m => ModuleT m Solver
setModuleEnv :: Monad m => ModuleEnv -> ModuleT m ()
modifyModuleEnv :: Monad m => (ModuleEnv -> ModuleEnv) -> ModuleT m ()
getLoadedMaybe :: ModName -> ModuleM (Maybe LoadedModule)
isLoaded :: ModName -> ModuleM Bool
loadingImport :: Located Import -> ModuleM a -> ModuleM a
loadingModule :: ModName -> ModuleM a -> ModuleM a
loadingModInstance :: Located ModName -> ModuleM a -> ModuleM a
-- | Push an "interactive" context onto the loading stack. A bit of a hack,
-- as it uses a faked module name
interactive :: ModuleM a -> ModuleM a
loading :: ImportSource -> ModuleM a -> ModuleM a
-- | Get the currently focused import source.
getImportSource :: ModuleM ImportSource
getIface :: ModName -> ModuleM Iface
getIfaces :: ModuleM (ModName -> Iface)
getLoaded :: ModName -> ModuleM Module
getNameSeeds :: ModuleM NameSeeds
getSupply :: ModuleM Supply
getMonoBinds :: ModuleM Bool
setMonoBinds :: Bool -> ModuleM ()
setNameSeeds :: NameSeeds -> ModuleM ()
setSupply :: Supply -> ModuleM ()
unloadModule :: (LoadedModule -> Bool) -> ModuleM ()
loadedModule :: ModulePath -> Fingerprint -> NamingEnv -> Module -> ModuleM ()
modifyEvalEnv :: (EvalEnv -> Eval EvalEnv) -> ModuleM ()
getEvalEnv :: ModuleM EvalEnv
getEvalOptsAction :: ModuleM (IO EvalOpts)
getEvalOpts :: ModuleM EvalOpts
getNewtypes :: ModuleM (Map Name Newtype)
getFocusedModule :: ModuleM (Maybe ModName)
setFocusedModule :: ModName -> ModuleM ()
getSearchPath :: ModuleM [FilePath]
-- | Run a ModuleM action in a context with a prepended search path.
-- Useful for temporarily looking in other places while resolving
-- imports, for example.
withPrependedSearchPath :: [FilePath] -> ModuleM a -> ModuleM a
getFocusedEnv :: ModuleM ModContext
getDynEnv :: ModuleM DynamicEnv
setDynEnv :: DynamicEnv -> ModuleM ()
-- | Usefule for logging. For example: withLogger logPutStrLn
-- Hello
withLogger :: (Logger -> a -> IO b) -> a -> ModuleM b
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Monad.ImportSource
instance GHC.Generics.Generic Cryptol.ModuleSystem.Monad.ImportSource
instance GHC.Show.Show Cryptol.ModuleSystem.Monad.ImportSource
instance GHC.Show.Show Cryptol.ModuleSystem.Monad.ModuleError
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Monad.ModuleWarning
instance GHC.Generics.Generic Cryptol.ModuleSystem.Monad.ModuleWarning
instance GHC.Show.Show Cryptol.ModuleSystem.Monad.ModuleWarning
instance GHC.Base.Monad m => GHC.Base.Functor (Cryptol.ModuleSystem.Monad.ModuleT m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Cryptol.ModuleSystem.Monad.ModuleT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Cryptol.ModuleSystem.Monad.ModuleT m)
instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Cryptol.ModuleSystem.Monad.ModuleT m)
instance MonadLib.MonadT Cryptol.ModuleSystem.Monad.ModuleT
instance GHC.Base.Monad m => Cryptol.ModuleSystem.Name.FreshM (Cryptol.ModuleSystem.Monad.ModuleT m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Cryptol.ModuleSystem.Monad.ModuleT m)
instance Cryptol.Utils.PP.PP Cryptol.ModuleSystem.Monad.ModuleWarning
instance Control.DeepSeq.NFData Cryptol.ModuleSystem.Monad.ModuleError
instance Cryptol.Utils.PP.PP Cryptol.ModuleSystem.Monad.ModuleError
instance GHC.Classes.Eq Cryptol.ModuleSystem.Monad.ImportSource
instance Cryptol.Utils.PP.PP Cryptol.ModuleSystem.Monad.ImportSource
-- | This is the main driver---it provides entry points for the various
-- passes.
module Cryptol.ModuleSystem.Base
rename :: ModName -> NamingEnv -> RenameM a -> ModuleM a
-- | Rename a module in the context of its imported modules.
renameModule :: Module PName -> ModuleM RenamedModule
-- | Run the noPat pass.
noPat :: RemovePatterns a => a -> ModuleM a
-- | Parse a module and expand includes
parseModule :: ModulePath -> ModuleM (Fingerprint, Module PName)
-- | Load a module by its path.
loadModuleByPath :: FilePath -> ModuleM Module
-- | Load a module, unless it was previously loaded.
loadModuleFrom :: Bool -> ImportSource -> ModuleM (ModulePath, Module)
-- | Load dependencies, typecheck, and add to the eval environment.
doLoadModule :: Bool -> ImportSource -> ModulePath -> Fingerprint -> Module PName -> ModuleM Module
-- | Rewrite an import declaration to be of the form:
--
--
-- import foo as foo [ [hiding] (a,b,c) ]
--
fullyQualified :: Import -> Import
moduleFile :: ModName -> String -> FilePath
-- | Discover a module.
findModule :: ModName -> ModuleM ModulePath
-- | Discover a file. This is distinct from findModule in that we
-- assume we've already been given a particular file name.
findFile :: FilePath -> ModuleM FilePath
-- | Add the prelude to the import list if it's not already mentioned.
addPrelude :: Module PName -> Module PName
-- | Load the dependencies of a module into the environment.
loadDeps :: Module name -> ModuleM ()
-- | Typecheck a single expression, yielding a renamed parsed expression,
-- typechecked core expression, and a type schema.
checkExpr :: Expr PName -> ModuleM (Expr Name, Expr, Schema)
-- | Typecheck a group of declarations.
--
-- INVARIANT: This assumes that NoPat has already been run on the
-- declarations.
checkDecls :: [TopDecl PName] -> ModuleM (NamingEnv, [DeclGroup], Map Name TySyn)
-- | Generate the primitive map. If the prelude is currently being loaded,
-- this should be generated directly from the naming environment given to
-- the renamer instead.
getPrimMap :: ModuleM PrimMap
-- | Load a module, be it a normal module or a functor instantiation.
checkModule :: ImportSource -> Module PName -> ModuleM (NamingEnv, Module)
-- | Typecheck a single module. If the module is an instantiation of a
-- functor, then this just type-checks the instantiating parameters. See
-- checkModule Note: we assume that includes have already
-- been processed
checkSingleModule :: Act (Module Name) Module -> ImportSource -> Module PName -> ModuleM (NamingEnv, Module)
data TCLinter o
TCLinter :: (o -> InferInput -> Either (Range, Error) [ProofObligation]) -> Maybe ModName -> TCLinter o
[lintCheck] :: TCLinter o -> o -> InferInput -> Either (Range, Error) [ProofObligation]
[lintModule] :: TCLinter o -> Maybe ModName
exprLinter :: TCLinter (Expr, Schema)
declsLinter :: TCLinter ([DeclGroup], a)
moduleLinter :: ModName -> TCLinter Module
type Act i o = i -> InferInput -> IO (InferOutput o)
data TCAction i o
TCAction :: Act i o -> TCLinter o -> PrimMap -> TCAction i o
[tcAction] :: TCAction i o -> Act i o
[tcLinter] :: TCAction i o -> TCLinter o
[tcPrims] :: TCAction i o -> PrimMap
typecheck :: (Show i, Show o, HasLoc i) => TCAction i o -> i -> IfaceParams -> IfaceDecls -> ModuleM o
-- | Generate input for the typechecker.
genInferInput :: Range -> PrimMap -> IfaceParams -> IfaceDecls -> ModuleM InferInput
evalExpr :: Expr -> ModuleM Value
evalDecls :: [DeclGroup] -> ModuleM ()
module Cryptol.ModuleSystem
-- | This is the current state of the interpreter.
data ModuleEnv
ModuleEnv :: LoadedModules -> NameSeeds -> EvalEnv -> CoreLint -> !Bool -> Maybe ModName -> [FilePath] -> DynamicEnv -> !Supply -> ModuleEnv
-- | Information about all loaded modules. See LoadedModule.
-- Contains information such as the file where the module was loaded
-- from, as well as the module's interface, used for type checking.
[meLoadedModules] :: ModuleEnv -> LoadedModules
-- | A source of new names for the type checker.
[meNameSeeds] :: ModuleEnv -> NameSeeds
-- | The evaluation environment. Contains the values for all loaded
-- modules, both public and private.
[meEvalEnv] :: ModuleEnv -> EvalEnv
-- | Should we run the linter to ensure sanity.
[meCoreLint] :: ModuleEnv -> CoreLint
-- | Are we assuming that local bindings are monomorphic. XXX: We should
-- probably remove this flag, and set it to True.
[meMonoBinds] :: ModuleEnv -> !Bool
-- | The "current" module. Used to decide how to print names, for example.
[meFocusedModule] :: ModuleEnv -> Maybe ModName
-- | Where we look for things.
[meSearchPath] :: ModuleEnv -> [FilePath]
-- | This contains additional definitions that were made at the command
-- line, and so they don't reside in any module.
[meDynEnv] :: ModuleEnv -> DynamicEnv
-- | Name source for the renamer
[meSupply] :: ModuleEnv -> !Supply
initialModuleEnv :: IO ModuleEnv
-- | Extra information we need to carry around to dynamically extend an
-- environment outside the context of a single module. Particularly
-- useful when dealing with interactive declarations as in let
-- or it.
data DynamicEnv
DEnv :: NamingEnv -> [DeclGroup] -> Map Name TySyn -> EvalEnv -> DynamicEnv
[deNames] :: DynamicEnv -> NamingEnv
[deDecls] :: DynamicEnv -> [DeclGroup]
[deTySyns] :: DynamicEnv -> Map Name TySyn
[deEnv] :: DynamicEnv -> EvalEnv
data ModuleError
-- | Unable to find the module given, tried looking in these paths
ModuleNotFound :: ModName -> [FilePath] -> ModuleError
-- | Unable to open a file
CantFindFile :: FilePath -> ModuleError
-- | Bad UTF-8 encoding in while decoding this file
BadUtf8 :: ModulePath -> UnicodeException -> ModuleError
-- | Some other IO error occurred while reading this file
OtherIOError :: FilePath -> IOException -> ModuleError
-- | Generated this parse error when parsing the file for module m
ModuleParseError :: ModulePath -> ParseError -> ModuleError
-- | Recursive module group discovered
RecursiveModules :: [ImportSource] -> ModuleError
-- | Problems during the renaming phase
RenamerErrors :: ImportSource -> [RenamerError] -> ModuleError
-- | Problems during the NoPat phase
NoPatErrors :: ImportSource -> [Error] -> ModuleError
-- | Problems during the NoInclude phase
NoIncludeErrors :: ImportSource -> [IncludeError] -> ModuleError
-- | Problems during type checking
TypeCheckingFailed :: ImportSource -> NameMap -> [(Range, Error)] -> ModuleError
-- | Problems after type checking, eg. specialization
OtherFailure :: String -> ModuleError
-- | Module loaded by 'import' statement has the wrong module name
ModuleNameMismatch :: ModName -> Located ModName -> ModuleError
-- | Two modules loaded from different files have the same module name
DuplicateModuleName :: ModName -> FilePath -> FilePath -> ModuleError
-- | Attempt to import a parametrized module that was not instantiated.
ImportedParamModule :: ModName -> ModuleError
-- | Failed to add the module parameters to all definitions in a module.
FailedToParameterizeModDefs :: ModName -> [Name] -> ModuleError
NotAParameterizedModule :: ModName -> ModuleError
-- | This is just a tag on the error, indicating the file containing it. It
-- is convenient when we had to look for the module, and we'd like to
-- communicate the location of pthe problematic module to the handler.
ErrorInFile :: ModulePath -> ModuleError -> ModuleError
data ModuleWarning
TypeCheckWarnings :: NameMap -> [(Range, Warning)] -> ModuleWarning
RenamerWarnings :: [RenamerWarning] -> ModuleWarning
type ModuleCmd a = ModuleInput IO -> IO (ModuleRes a)
type ModuleRes a = (Either ModuleError (a, ModuleEnv), [ModuleWarning])
data ModuleInput m
ModuleInput :: Bool -> m EvalOpts -> (FilePath -> m ByteString) -> ModuleEnv -> Solver -> ModuleInput m
[minpCallStacks] :: ModuleInput m -> Bool
[minpEvalOpts] :: ModuleInput m -> m EvalOpts
[minpByteReader] :: ModuleInput m -> FilePath -> m ByteString
[minpModuleEnv] :: ModuleInput m -> ModuleEnv
[minpTCSolver] :: ModuleInput m -> Solver
-- | Find the file associated with a module name in the module search path.
findModule :: ModName -> ModuleCmd ModulePath
-- | Load the module contained in the given file.
loadModuleByPath :: FilePath -> ModuleCmd (ModulePath, Module)
-- | Load the given parsed module.
loadModuleByName :: ModName -> ModuleCmd (ModulePath, Module)
-- | Check the type of an expression. Give back the renamed expression, the
-- core expression, and its type schema.
checkExpr :: Expr PName -> ModuleCmd (Expr Name, Expr, Schema)
-- | Evaluate an expression.
evalExpr :: Expr -> ModuleCmd Value
-- | Typecheck top-level declarations.
checkDecls :: [TopDecl PName] -> ModuleCmd (NamingEnv, [DeclGroup], Map Name TySyn)
-- | Evaluate declarations and add them to the extended environment.
evalDecls :: [DeclGroup] -> ModuleCmd ()
noPat :: RemovePatterns a => a -> ModuleCmd a
-- | Given the state of the environment, compute information about what's
-- in scope on the REPL. This includes what's in the focused module, plus
-- any additional definitions from the REPL (e.g., let bound names, and
-- it).
focusedEnv :: ModuleEnv -> ModContext
getPrimMap :: ModuleCmd PrimMap
-- | Rename a *use* of a value name. The distinction between uses and
-- binding is used to keep track of dependencies.
renameVar :: NamingEnv -> PName -> ModuleCmd Name
-- | Rename a *use* of a type name. The distinction between uses and
-- binding is used to keep track of dependencies.
renameType :: NamingEnv -> PName -> ModuleCmd Name
type Iface = IfaceG ModName
-- | The resulting interface generated by a module that has been
-- typechecked.
data IfaceG mname
Iface :: !mname -> IfaceDecls -> IfaceDecls -> IfaceParams -> IfaceG mname
-- | Module name
[ifModName] :: IfaceG mname -> !mname
-- | Exported definitions
[ifPublic] :: IfaceG mname -> IfaceDecls
-- | Private defintiions
[ifPrivate] :: IfaceG mname -> IfaceDecls
-- | Uninterpreted constants (aka module params)
[ifParams] :: IfaceG mname -> IfaceParams
data IfaceParams
IfaceParams :: Map Name ModTParam -> [Located Prop] -> Map Name ModVParam -> IfaceParams
[ifParamTypes] :: IfaceParams -> Map Name ModTParam
-- | Constraints on param. types
[ifParamConstraints] :: IfaceParams -> [Located Prop]
[ifParamFuns] :: IfaceParams -> Map Name ModVParam
data IfaceDecls
IfaceDecls :: Map Name IfaceTySyn -> Map Name IfaceNewtype -> Map Name IfaceAbstractType -> Map Name IfaceDecl -> !Map Name (IfaceG Name) -> IfaceDecls
[ifTySyns] :: IfaceDecls -> Map Name IfaceTySyn
[ifNewtypes] :: IfaceDecls -> Map Name IfaceNewtype
[ifAbstractTypes] :: IfaceDecls -> Map Name IfaceAbstractType
[ifDecls] :: IfaceDecls -> Map Name IfaceDecl
[ifModules] :: IfaceDecls -> !Map Name (IfaceG Name)
-- | Generate an Iface from a typechecked module.
genIface :: ModuleG mname -> IfaceG mname
type IfaceTySyn = TySyn
data IfaceDecl
IfaceDecl :: !Name -> Schema -> [Pragma] -> Bool -> Maybe Fixity -> Maybe Text -> IfaceDecl
-- | Name of thing
[ifDeclName] :: IfaceDecl -> !Name
-- | Type
[ifDeclSig] :: IfaceDecl -> Schema
-- | Pragmas
[ifDeclPragmas] :: IfaceDecl -> [Pragma]
-- | Is this an infix thing
[ifDeclInfix] :: IfaceDecl -> Bool
-- | Fixity information
[ifDeclFixity] :: IfaceDecl -> Maybe Fixity
-- | Documentation
[ifDeclDoc] :: IfaceDecl -> Maybe Text
module Cryptol.Transform.Specialize
-- | A Name should have an entry in the SpecCache iff it is
-- specializable. Each Name starts out with an empty
-- TypesMap.
type SpecCache = Map Name (Decl, TypesMap (Name, Maybe Decl))
-- | The specializer monad.
type SpecT m a = StateT SpecCache (ModuleT m) a
type SpecM a = SpecT IO a
runSpecT :: SpecCache -> SpecT m a -> ModuleT m (a, SpecCache)
liftSpecT :: Monad m => ModuleT m a -> SpecT m a
getSpecCache :: Monad m => SpecT m SpecCache
setSpecCache :: Monad m => SpecCache -> SpecT m ()
modifySpecCache :: Monad m => (SpecCache -> SpecCache) -> SpecT m ()
modify :: StateM m s => (s -> s) -> m ()
-- | Add a where clause to the given expression containing
-- type-specialized versions of all functions called (transitively) by
-- the body of the expression.
specialize :: Expr -> ModuleCmd Expr
specializeExpr :: Expr -> SpecM Expr
specializeMatch :: Match -> SpecM Match
-- | Add the declarations to the SpecCache, run the given monadic action,
-- and then pull the specialized declarations back out of the SpecCache
-- state. Return the result along with the declarations and a table of
-- names of specialized bindings.
withDeclGroups :: [DeclGroup] -> SpecM a -> SpecM (a, [DeclGroup], Map Name (TypesMap Name))
-- | Compute the specialization of EWhere e dgs. A decl
-- within dgs is replicated once for each monomorphic type
-- instance at which it is used; decls not mentioned in e (even
-- monomorphic ones) are simply dropped.
specializeEWhere :: Expr -> [DeclGroup] -> SpecM Expr
-- | Transform the given declaration groups into a set of monomorphic
-- declarations. All of the original declarations with monomorphic types
-- are kept; additionally the result set includes instantiated versions
-- of polymorphic decls that are referenced by the monomorphic bindings.
-- We also return a map relating generated names to the names from the
-- original declarations.
specializeDeclGroups :: [DeclGroup] -> SpecM ([DeclGroup], Map Name (TypesMap Name))
specializeConst :: Expr -> SpecM Expr
destEProofApps :: Expr -> (Expr, Int)
destETApps :: Expr -> (Expr, [Type])
destEProofAbs :: Expr -> ([Prop], Expr)
destETAbs :: Expr -> ([TParam], Expr)
-- | Freshen a name by giving it a new unique.
freshName :: Name -> [Type] -> SpecM Name
instantiateSchema :: [Type] -> Int -> Schema -> SpecM Schema
-- | Reduce length ts outermost type abstractions and n
-- proof abstractions.
instantiateExpr :: [Type] -> Int -> Expr -> SpecM Expr
allDeclGroups :: ModuleEnv -> [DeclGroup]
traverseSnd :: Functor f => (b -> f c) -> (a, b) -> f (a, c)
module Cryptol.Symbolic.What4
data W4ProverConfig
defaultProver :: W4ProverConfig
proverNames :: [String]
setupProver :: String -> IO (Either String ([String], W4ProverConfig))
satProve :: W4ProverConfig -> Bool -> Bool -> ProverCommand -> ModuleCmd (Maybe String, ProverResult)
satProveOffline :: Bool -> Bool -> ProverCommand -> ((Handle -> IO ()) -> IO ()) -> ModuleCmd (Maybe String)
data W4Exception
W4Ex :: SomeException -> W4Exception
W4PortfolioFailure :: [Either SomeException (Maybe String, String)] -> W4Exception
instance GHC.Base.Functor Cryptol.Symbolic.What4.MultiSat
instance GHC.Base.Applicative Cryptol.Symbolic.What4.MultiSat
instance GHC.Base.Monad Cryptol.Symbolic.What4.MultiSat
instance Control.Monad.IO.Class.MonadIO Cryptol.Symbolic.What4.MultiSat
instance GHC.Show.Show Cryptol.Symbolic.What4.W4Exception
instance GHC.Exception.Type.Exception Cryptol.Symbolic.What4.W4Exception
module Cryptol.Symbolic.SBV
data SBVProverConfig
defaultProver :: SBVProverConfig
-- | The names of all the solvers supported by SBV
proverNames :: [String]
setupProver :: String -> IO (Either String ([String], SBVProverConfig))
-- | Execute a symbolic ':prove' or ':sat' command.
--
-- This command returns a pair: the first element is the name of the
-- solver that completes the given query (if any) along with the result
-- of executing the query.
satProve :: SBVProverConfig -> ProverCommand -> ModuleCmd (Maybe String, ProverResult)
-- | Execute a symbolic ':prove' or ':sat' command when the prover is set
-- to offline. This only prepares the SMT input file for the solver and
-- does not actually invoke the solver.
--
-- This method returns either an error message or the text of the SMT
-- input file corresponding to the given prover command.
satProveOffline :: SBVProverConfig -> ProverCommand -> ModuleCmd (Either String String)
newtype SBVPortfolioException
SBVPortfolioException :: [Either SomeException (Maybe String, String)] -> SBVPortfolioException
instance GHC.Show.Show Cryptol.Symbolic.SBV.SBVPortfolioException
instance GHC.Exception.Type.Exception Cryptol.Symbolic.SBV.SBVPortfolioException
module Cryptol.REPL.Monad
-- | REPL_ context with InputT handling.
newtype REPL a
REPL :: (IORef RW -> IO a) -> REPL a
[unREPL] :: REPL a -> IORef RW -> IO a
-- | Run a REPL action with a fresh environment.
runREPL :: Bool -> Bool -> Logger -> REPL a -> IO a
io :: IO a -> REPL a
-- | Raise an exception.
raise :: REPLException -> REPL a
stop :: REPL ()
catch :: REPL a -> (REPLException -> REPL a) -> REPL a
finally :: REPL a -> REPL b -> REPL a
-- | Use the configured output action to print a string with a trailing
-- newline
rPutStrLn :: String -> REPL ()
-- | Use the configured output action to print a string
rPutStr :: String -> REPL ()
-- | Use the configured output action to print something using its Show
-- instance
rPrint :: Show a => a -> REPL ()
-- | REPL exceptions.
data REPLException
ParseError :: ParseError -> REPLException
FileNotFound :: FilePath -> REPLException
DirectoryNotFound :: FilePath -> REPLException
NoPatError :: [Error] -> REPLException
NoIncludeError :: [IncludeError] -> REPLException
EvalError :: EvalErrorEx -> REPLException
TooWide :: WordTooWide -> REPLException
Unsupported :: Unsupported -> REPLException
ModuleSystemError :: NameDisp -> ModuleError -> REPLException
EvalPolyError :: Schema -> REPLException
TypeNotTestable :: Type -> REPLException
EvalInParamModule :: [Name] -> REPLException
SBVError :: String -> REPLException
SBVException :: SBVException -> REPLException
SBVPortfolioException :: SBVPortfolioException -> REPLException
W4Exception :: W4Exception -> REPLException
rethrowEvalError :: IO a -> IO a
getFocusedEnv :: REPL ModContext
getModuleEnv :: REPL ModuleEnv
setModuleEnv :: ModuleEnv -> REPL ()
getDynEnv :: REPL DynamicEnv
setDynEnv :: DynamicEnv -> REPL ()
getCallStacks :: REPL Bool
getTCSolver :: REPL Solver
resetTCSolver :: REPL ()
-- | Given an existing qualified name, prefix it with a relatively-unique
-- string. We make it unique by prefixing with a character #
-- that is not lexically valid in a module name.
uniqify :: Name -> REPL Name
-- | Generate a fresh name using the given index. The name will reside
-- within the "interactive" namespace.
freshName :: Ident -> NameSource -> REPL Name
whenDebug :: REPL () -> REPL ()
getEvalOptsAction :: REPL (IO EvalOpts)
getPPValOpts :: REPL PPOpts
-- | Get visible variable names. This is used for command line
-- completition.
getExprNames :: REPL [String]
-- | Get visible type signature names. This is used for command line
-- completition.
getTypeNames :: REPL [String]
-- | Return a list of property names, sorted by position in the file.
getPropertyNames :: REPL ([(Name, IfaceDecl)], NameDisp)
getModNames :: REPL [ModName]
-- | This indicates what the user would like to work on.
data LoadedModule
LoadedModule :: Maybe ModName -> ModulePath -> LoadedModule
-- | Working on this module.
[lName] :: LoadedModule -> Maybe ModName
-- | Working on this file.
[lPath] :: LoadedModule -> ModulePath
getLoadedMod :: REPL (Maybe LoadedModule)
-- | Set the name of the currently focused file, loaded via :r.
setLoadedMod :: LoadedModule -> REPL ()
clearLoadedMod :: REPL ()
-- | Set the path for the ':e' command. Note that this does not change the
-- focused module (i.e., what ":r" reloads)
setEditPath :: FilePath -> REPL ()
getEditPath :: REPL (Maybe FilePath)
clearEditPath :: REPL ()
setSearchPath :: [FilePath] -> REPL ()
prependSearchPath :: [FilePath] -> REPL ()
-- | Construct the prompt for the current environment.
getPrompt :: REPL String
shouldContinue :: REPL Bool
unlessBatch :: REPL () -> REPL ()
-- | Run a computation in batch mode, restoring the previous isBatch flag
-- afterwards
asBatch :: REPL a -> REPL a
-- | Is evaluation enabled. If the currently focused module is
-- parameterized, then we cannot evalute.
validEvalContext :: FreeVars a => a -> REPL ()
-- | Update the title
updateREPLTitle :: REPL ()
-- | Set the function that will be called when updating the title
setUpdateREPLTitle :: REPL () -> REPL ()
data EnvVal
EnvString :: String -> EnvVal
EnvProg :: String -> [String] -> EnvVal
EnvNum :: !Int -> EnvVal
EnvBool :: Bool -> EnvVal
data OptionDescr
OptionDescr :: String -> [String] -> EnvVal -> Checker -> String -> (EnvVal -> REPL ()) -> OptionDescr
[optName] :: OptionDescr -> String
[optAliases] :: OptionDescr -> [String]
[optDefault] :: OptionDescr -> EnvVal
[optCheck] :: OptionDescr -> Checker
[optHelp] :: OptionDescr -> String
[optEff] :: OptionDescr -> EnvVal -> REPL ()
-- | Set a user option.
setUser :: String -> String -> REPL ()
-- | Get a user option, when it's known to exist. Fail with panic when it
-- doesn't.
getUser :: String -> REPL EnvVal
getKnownUser :: IsEnvVal a => String -> REPL a
-- | Get a user option, using Maybe for failure.
tryGetUser :: String -> REPL (Maybe EnvVal)
userOptions :: OptionMap
userOptionsWithAliases :: OptionMap
getUserSatNum :: REPL SatNum
getUserShowProverStats :: REPL Bool
getUserProverValidate :: REPL Bool
parsePPFloatFormat :: String -> Maybe PPFloatFormat
parseFieldOrder :: String -> Maybe FieldOrder
getProverConfig :: REPL (Either SBVProverConfig W4ProverConfig)
parseSearchPath :: String -> [String]
-- | Get the REPL's string-printer
getPutStr :: REPL (String -> IO ())
getLogger :: REPL Logger
-- | Set the REPL's string-printer
setPutStr :: (String -> IO ()) -> REPL ()
smokeTest :: REPL [Smoke]
data Smoke
Z3NotFound :: Smoke
instance GHC.Show.Show Cryptol.REPL.Monad.REPLException
instance GHC.Show.Show Cryptol.REPL.Monad.EnvVal
instance GHC.Classes.Eq Cryptol.REPL.Monad.Smoke
instance GHC.Show.Show Cryptol.REPL.Monad.Smoke
instance Cryptol.Utils.PP.PP Cryptol.REPL.Monad.Smoke
instance Cryptol.REPL.Monad.IsEnvVal GHC.Types.Bool
instance Cryptol.REPL.Monad.IsEnvVal GHC.Types.Int
instance Cryptol.REPL.Monad.IsEnvVal (GHC.Base.String, [GHC.Base.String])
instance Cryptol.REPL.Monad.IsEnvVal GHC.Base.String
instance Cryptol.REPL.Monad.IsEnvVal Cryptol.Utils.PP.FieldOrder
instance GHC.Base.Functor Cryptol.REPL.Monad.REPL
instance GHC.Base.Applicative Cryptol.REPL.Monad.REPL
instance GHC.Base.Monad Cryptol.REPL.Monad.REPL
instance Control.Monad.IO.Class.MonadIO Cryptol.REPL.Monad.REPL
instance Control.Monad.Base.MonadBase GHC.Types.IO Cryptol.REPL.Monad.REPL
instance Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO Cryptol.REPL.Monad.REPL
instance Cryptol.ModuleSystem.Name.FreshM Cryptol.REPL.Monad.REPL
instance Control.Monad.Catch.MonadThrow Cryptol.REPL.Monad.REPL
instance Control.Monad.Catch.MonadCatch Cryptol.REPL.Monad.REPL
instance Control.Monad.Catch.MonadMask Cryptol.REPL.Monad.REPL
instance GHC.Exception.Type.Exception Cryptol.REPL.Monad.REPLException
instance Cryptol.Utils.PP.PP Cryptol.REPL.Monad.REPLException
module Cryptol.Eval.Reference
-- | Value type for the reference evaluator.
data Value
-- | Bit booleans
VBit :: !Bool -> Value
-- | Integer or Z n integers
VInteger :: !Integer -> Value
-- | Rational rationals
VRational :: !Rational -> Value
-- | Floating point numbers
VFloat :: !BF -> Value
-- | [n]a finite or infinite lists
VList :: Nat' -> [E Value] -> Value
-- | ( .. ) tuples
VTuple :: [E Value] -> Value
-- | { .. } records
VRecord :: [(Ident, E Value)] -> Value
-- | functions
VFun :: (E Value -> E Value) -> Value
-- | polymorphic values (kind *)
VPoly :: (TValue -> E Value) -> Value
-- | polymorphic values (kind #)
VNumPoly :: (Nat' -> E Value) -> Value
-- | Computation monad for the reference evaluator.
data E a
Value :: !a -> E a
Err :: EvalError -> E a
evaluate :: Expr -> ModuleCmd (E Value)
evalExpr :: Env -> Expr -> E Value
evalDeclGroup :: Env -> DeclGroup -> Env
ppValue :: PPOpts -> Value -> Doc
ppEValue :: PPOpts -> E Value -> Doc
instance GHC.Base.Semigroup Cryptol.Eval.Reference.Env
instance GHC.Base.Monoid Cryptol.Eval.Reference.Env
instance GHC.Base.Functor Cryptol.Eval.Reference.E
instance GHC.Base.Applicative Cryptol.Eval.Reference.E
instance GHC.Base.Monad Cryptol.Eval.Reference.E
module Cryptol.REPL.Command
-- | Commands.
data Command
-- | Successfully parsed command
Command :: (Int -> Maybe FilePath -> REPL ()) -> Command
-- | Ambiguous command, list of conflicting commands
Ambiguous :: String -> [String] -> Command
-- | The unknown command
Unknown :: String -> Command
-- | Command builder.
data CommandDescr
CommandDescr :: [String] -> [String] -> CommandBody -> String -> String -> CommandDescr
[cNames] :: CommandDescr -> [String]
[cArgs] :: CommandDescr -> [String]
[cBody] :: CommandDescr -> CommandBody
[cHelp] :: CommandDescr -> String
[cLongHelp] :: CommandDescr -> String
data CommandBody
ExprArg :: (String -> (Int, Int) -> Maybe FilePath -> REPL ()) -> CommandBody
FileExprArg :: (FilePath -> String -> (Int, Int) -> Maybe FilePath -> REPL ()) -> CommandBody
DeclsArg :: (String -> REPL ()) -> CommandBody
ExprTypeArg :: (String -> REPL ()) -> CommandBody
ModNameArg :: (String -> REPL ()) -> CommandBody
FilenameArg :: (FilePath -> REPL ()) -> CommandBody
OptionArg :: (String -> REPL ()) -> CommandBody
ShellArg :: (String -> REPL ()) -> CommandBody
HelpArg :: (String -> REPL ()) -> CommandBody
NoArg :: REPL () -> CommandBody
data CommandExitCode
CommandOk :: CommandExitCode
CommandError :: CommandExitCode
-- | Parse a line as a command.
parseCommand :: (String -> [CommandDescr]) -> String -> Maybe Command
-- | Run a command.
runCommand :: Int -> Maybe FilePath -> Command -> REPL CommandExitCode
-- | Split at the first word boundary.
splitCommand :: String -> Maybe (Int, String, String)
-- | Lookup a string in the command list.
findCommand :: String -> [CommandDescr]
-- | Lookup a string in the command list, returning an exact match even if
-- it's the prefix of another command.
findCommandExact :: String -> [CommandDescr]
-- | Lookup a string in the notebook-safe command list.
findNbCommand :: Bool -> String -> [CommandDescr]
commandList :: [CommandDescr]
moduleCmd :: String -> REPL ()
loadCmd :: FilePath -> REPL ()
loadPrelude :: REPL ()
setOptionCmd :: String -> REPL ()
interactiveConfig :: Config
replParseExpr :: String -> (Int, Int) -> Maybe FilePath -> REPL (Expr PName)
replEvalExpr :: Expr PName -> REPL (Value, Type)
replCheckExpr :: Expr PName -> REPL (Expr Name, Expr, Schema)
data TestReport
TestReport :: Doc -> TestResult -> Integer -> Maybe Integer -> TestReport
[reportExpr] :: TestReport -> Doc
[reportResult] :: TestReport -> TestResult
[reportTestsRun] :: TestReport -> Integer
[reportTestsPossible] :: TestReport -> Maybe Integer
qcExpr :: QCMode -> Doc -> Expr -> Schema -> REPL TestReport
-- | Randomly test a property, or exhaustively check it if the number of
-- values in the type under test is smaller than the tests
-- environment variable, or we specify exhaustive testing.
qcCmd :: QCMode -> String -> (Int, Int) -> Maybe FilePath -> REPL ()
data QCMode
QCRandom :: QCMode
QCExhaust :: QCMode
satCmd :: String -> (Int, Int) -> Maybe FilePath -> REPL ()
proveCmd :: String -> (Int, Int) -> Maybe FilePath -> REPL ()
onlineProveSat :: String -> QueryType -> Expr -> Schema -> Maybe FilePath -> REPL (Maybe String, ProverResult, ProverStats)
offlineProveSat :: String -> QueryType -> Expr -> Schema -> Maybe FilePath -> REPL ()
handleCtrlC :: a -> REPL a
-- | Strip leading space.
sanitize :: String -> String
withRWTempFile :: String -> (Handle -> IO a) -> IO a
-- | Lift a parsing action into the REPL monad.
replParse :: (String -> Either ParseError a) -> String -> REPL a
liftModuleCmd :: ModuleCmd a -> REPL a
moduleCmdResult :: ModuleRes a -> REPL a
instance GHC.Show.Show Cryptol.REPL.Command.QCMode
instance GHC.Classes.Eq Cryptol.REPL.Command.QCMode
instance GHC.Show.Show Cryptol.REPL.Command.CommandDescr
instance GHC.Classes.Eq Cryptol.REPL.Command.CommandDescr
instance GHC.Classes.Ord Cryptol.REPL.Command.CommandDescr