Safe Haskell	None
Language	Haskell2010

Unison.Term

Synopsis

data MatchCase loc a = MatchCase {
- matchPattern :: Pattern loc
- matchGuard :: Maybe a
- matchBody :: a
}
matchPattern_ :: forall loc a f. Functor f => (Pattern loc -> f (Pattern loc)) -> MatchCase loc a -> f (MatchCase loc a)
data F typeVar typeAnn patternAnn a
- = Int Int64
- | Nat Word64
- | Float Double
- | Boolean Bool
- | Text Text
- | Char Char
- | Blank (Blank typeAnn)
- | Ref Reference
- | Constructor ConstructorReference
- | Request ConstructorReference
- | Handle a a
- | App a a
- | Ann a (Type typeVar typeAnn)
- | List (Seq a)
- | If a a a
- | And a a
- | Or a a
- | Lam a
- | LetRec IsTop [a] a
- | Let IsTop a a
- | Match a [MatchCase patternAnn a]
- | TermLink Referent
- | TypeLink Reference
- | Record (Map Text a)
- | RecordSet Text a a
- | RecordSetBlock [Text] [(Text, a)] a
recordSetTargetName :: Text
_Ref :: forall tv ta pa a p f. (Choice p, Applicative f) => p Reference (f Reference) -> p (F tv ta pa a) (f (F tv ta pa a))
_Match :: forall tv ta pa a p f. (Choice p, Applicative f) => p (a, [MatchCase pa a]) (f (a, [MatchCase pa a])) -> p (F tv ta pa a) (f (F tv ta pa a))
_Constructor :: forall tv ta pa a p f. (Choice p, Applicative f) => p ConstructorReference (f ConstructorReference) -> p (F tv ta pa a) (f (F tv ta pa a))
_Request :: forall tv ta pa a p f. (Choice p, Applicative f) => p ConstructorReference (f ConstructorReference) -> p (F tv ta pa a) (f (F tv ta pa a))
_Ann :: forall tv ta pa a p f. (Choice p, Applicative f) => p (a, Term F tv ta) (f (a, Term F tv ta)) -> p (F tv ta pa a) (f (F tv ta pa a))
_TermLink :: forall tv ta pa a p f. (Choice p, Applicative f) => p Referent (f Referent) -> p (F tv ta pa a) (f (F tv ta pa a))
_TypeLink :: forall tv ta pa a p f. (Choice p, Applicative f) => p Reference (f Reference) -> p (F tv ta pa a) (f (F tv ta pa a))
getTypeAnnotation :: Term v a -> Maybe (Type v a)
type IsTop = Bool
type Term v a = Term2 v a a v a
type Term' vt v a = Term2 vt a a v a
type Term2 vt at ap v a = Term (F vt at ap) v a
type Term3 v a = Term2 v () () v a
type Term0 v = Term v ()
type Term0' vt v = Term' vt v ()
bindNames :: Var v => (v -> Name) -> (Name -> v) -> Set v -> Names -> Term v a -> ResolutionResult a (Term v a)
prepareTDNR :: Var v => Term (F vt b ap) v b -> Term (F vt b ap) v b
amap :: Ord v => (a -> a2) -> Term v a -> Term v a2
patternMap :: (Pattern ap -> Pattern ap2) -> Term2 vt at ap v a -> Term2 vt at ap2 v a
vmap :: Ord v2 => (v -> v2) -> Term v a -> Term v2 a
vtmap :: Ord vt2 => (vt -> vt2) -> Term' vt v a -> Term' vt2 v a
typeMap :: Ord vt2 => (Type vt at -> Type vt2 at2) -> Term2 vt at ap v a -> Term2 vt2 at2 ap v a
extraMap' :: (Ord vt, Ord vt') => (vt -> vt') -> (at -> at') -> (ap -> ap') -> Term2 vt at ap v a -> Term2 vt' at' ap' v a
extraMap :: (Ord vt, Ord vt') => (vt -> vt') -> (at -> at') -> (ap -> ap') -> F vt at ap a -> F vt' at' ap' a
matchCaseExtraMap :: (loc -> loc') -> MatchCase loc a -> MatchCase loc' a
unannotate :: forall vt at ap v a. Ord v => Term2 vt at ap v a -> Term0' vt v
wrapV :: Ord v => Term v a -> Term (V v) a
allVars :: Ord v => Term v a -> Set v
freeVars :: Term' vt v a -> Set v
freeTypeVars :: Ord vt => Term' vt v a -> Set vt
freeTypeVarAnnotations :: Ord vt => Term' vt v a -> Map vt [a]
substTypeVars :: (Ord v, Var vt) => [(vt, Type vt b)] -> Term' vt v a -> Term' vt v a
substTypeVar :: (Ord v, Var vt) => vt -> Type vt b -> Term' vt v a -> Term' vt v a
renameTypeVar :: (Ord v, Var vt) => vt -> vt -> Term' vt v a -> Term' vt v a
generalizeTypeSignatures :: (Var vt, Var v) => Term' vt v a -> Term' vt v a
pattern Var' :: v -> Term f v a
pattern Cycle' :: [v] -> f (Term f v a) -> Term f v a
pattern Abs' :: (Foldable f, Functor f, Var v) => Subst f v a -> Term f v a
pattern Int' :: Int64 -> Term (F typeVar typeAnn patternAnn) v a
pattern Nat' :: Word64 -> Term (F typeVar typeAnn patternAnn) v a
pattern Float' :: Double -> Term (F typeVar typeAnn patternAnn) v a
pattern Boolean' :: Bool -> Term (F typeVar typeAnn patternAnn) v a
pattern Text' :: Text -> Term (F typeVar typeAnn patternAnn) v a
pattern Char' :: Char -> Term (F typeVar typeAnn patternAnn) v a
pattern Blank' :: Blank typeAnn -> Term (F typeVar typeAnn patternAnn) v a
pattern Ref' :: Reference -> Term (F typeVar typeAnn patternAnn) v a
pattern TermLink' :: Referent -> Term (F typeVar typeAnn patternAnn) v a
pattern TypeLink' :: Reference -> Term (F typeVar typeAnn patternAnn) v a
pattern Builtin' :: Text -> Term (F typeVar typeAnn patternAnn) v a
pattern App' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern Match' :: Term (F typeVar typeAnn patternAnn) v a -> [MatchCase patternAnn (Term (F typeVar typeAnn patternAnn) v a)] -> Term (F typeVar typeAnn patternAnn) v a
pattern Constructor' :: ConstructorReference -> Term (F typeVar typeAnn patternAnn) v a
pattern Record' :: Map Text (Term (F typeVar typeAnn patternAnn) v a) -> Term (F typeVar typeAnn patternAnn) v a
pattern RecordSet' :: Text -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern RecordSetBlock' :: [Text] -> [(Text, Term (F typeVar typeAnn patternAnn) v a)] -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern Request' :: ConstructorReference -> Term (F typeVar typeAnn patternAnn) v a
pattern RequestOrCtor' :: ConstructorReference -> Term2 vt at ap v a
pattern If' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern And' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern Or' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern Handle' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern Apps' :: Term2 vt at ap v a -> [Term2 vt at ap v a] -> Term2 vt at ap v a
pattern Ands' :: [Term2 vt at ap v a] -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern Ors' :: [Term2 vt at ap v a] -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern AppsPred' :: Term2 vt at ap v a -> [Term2 vt at ap v a] -> (Term2 vt at ap v a, Term2 vt at ap v a -> Bool)
pattern BinaryApp' :: Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern BinaryApps' :: [(Term2 vt at ap v a, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern BinaryAppsPred' :: [(Term2 vt at ap v a, Term2 vt at ap v a)] -> Term2 vt at ap v a -> (Term2 vt at ap v a, Term2 vt at ap v a -> Bool)
pattern BinaryAppPred' :: Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a -> (Term2 vt at ap v a, Term2 vt at ap v a -> Bool)
pattern OverappliedBinaryAppPred' :: Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a -> [Term2 vt at ap v a] -> (Term2 vt at ap v a, Term2 vt at ap v a -> Bool)
pattern Ann' :: Term (F typeVar typeAnn patternAnn) v a -> Type typeVar typeAnn -> Term (F typeVar typeAnn patternAnn) v a
pattern List' :: Seq (Term (F typeVar typeAnn patternAnn) v a) -> Term (F typeVar typeAnn patternAnn) v a
pattern Lam' :: Var v => a -> Subst (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern Delay' :: Var v => Term2 vt at ap v a -> Term2 vt at ap v a
unDelay :: Var v => Term2 vt at ap v a -> Maybe (Term2 vt at ap v a)
pattern LamNamed' :: v -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern LamsNamed' :: [v] -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern LamsNamedOpt' :: [v] -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern LamsNamedPred' :: [v] -> Term2 vt at ap v a -> (Term2 vt at ap v a, v -> Bool)
pattern LamsNamedOrDelay' :: Var v => [v] -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern Let1' :: Var v => Term' vt v a -> a -> Subst (F vt a a) v a -> Term' vt v a
pattern Let1Top' :: Var v => IsTop -> Term' vt v a -> a -> Subst (F vt a a) v a -> Term' vt v a
pattern Let1Named' :: v -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern Let1NamedTop' :: IsTop -> v -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a
pattern Lets' :: [(IsTop, v, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern LetRecNamed' :: [(v, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern LetRecNamedTop' :: IsTop -> [(v, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern LetRec' :: (Monad m, Var v) => ((v -> m v) -> m ([(v, Term2 vt at ap v a)], Term2 vt at ap v a)) -> Term2 vt at ap v a
pattern LetRecTop' :: (Monad m, Var v) => IsTop -> ((v -> m v) -> m ([(v, Term2 vt at ap v a)], Term2 vt at ap v a)) -> Term2 vt at ap v a
pattern LetRecAnnotatedTop' :: (Monad m, Var v) => IsTop -> ((v -> m v) -> m ([((a, v), Term2 vt at ap v a)], Term2 vt at ap v a)) -> Term2 vt at ap v a
pattern LetRecNamedAnnotated' :: a -> [((a, v), Term' vt v a)] -> Term' vt v a -> Term' vt v a
pattern LetRecNamedAnnotatedTop' :: IsTop -> a -> [((a, v), Term' vt v a)] -> Term' vt v a -> Term' vt v a
fresh :: Var v => Term0 v -> v -> v
var :: a -> v -> Term2 vt at ap v a
var' :: Var v => Text -> Term0' vt v
ref :: Ord v => a -> Reference -> Term2 vt at ap v a
pattern Referent' :: Referent -> Term2 vt at ap v a
unReferent :: Term2 vt at ap v a -> Maybe Referent
refId :: Ord v => a -> Id -> Term2 vt at ap v a
termLink :: Ord v => a -> Referent -> Term2 vt at ap v a
typeLink :: Ord v => a -> Reference -> Term2 vt at ap v a
builtin :: Ord v => a -> Text -> Term2 vt at ap v a
float :: Ord v => a -> Double -> Term2 vt at ap v a
boolean :: Ord v => a -> Bool -> Term2 vt at ap v a
int :: Ord v => a -> Int64 -> Term2 vt at ap v a
nat :: Ord v => a -> Word64 -> Term2 vt at ap v a
text :: Ord v => a -> Text -> Term2 vt at ap v a
char :: Ord v => a -> Char -> Term2 vt at ap v a
watch :: (Var v, Semigroup a) => a -> String -> Term v a -> Term v a
watchMaybe :: (Var v, Semigroup a) => Maybe String -> Term v a -> Term v a
blank :: Ord v => a -> Term2 vt at ap v a
placeholder :: Ord v => a -> String -> Term2 vt a ap v a
resolve :: Ord v => at -> ab -> String -> Term2 vt ab ap v at
missingResult :: Ord v => at -> ab -> Term2 vt ab ap v at
constructor :: Ord v => a -> ConstructorReference -> Term2 vt at ap v a
request :: Ord v => a -> ConstructorReference -> Term2 vt at ap v a
record :: Ord v => a -> Map Text (Term2 vt at ap v a) -> Term2 vt at ap v a
recordSet :: Ord v => a -> Text -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
recordSetBlock :: (Ord vt, Ord v) => a -> [Text] -> [(Text, Term2 vt at a v a)] -> Term2 vt at a v a -> Term2 vt at a v a
recordProjection :: (Ord vt, Ord v, Var v) => a -> a -> Term2 vt at a v a -> Text -> Term2 vt at a v a
expandRecordSetBlock :: (Ord vt, Ord v, Var v) => Term2 vt at a v a -> Term2 vt at a v a
app_ :: Ord v => Term0' vt v -> Term0' vt v -> Term0' vt v
app :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
match :: Ord v => a -> Term2 vt at a v a -> [MatchCase a (Term2 vt at a v a)] -> Term2 vt at a v a
handle :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
and :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
or :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
list :: Ord v => a -> [Term2 vt at ap v a] -> Term2 vt at ap v a
list' :: Ord v => a -> Seq (Term2 vt at ap v a) -> Term2 vt at ap v a
apps :: Ord v => Term2 vt at ap v a -> [(a, Term2 vt at ap v a)] -> Term2 vt at ap v a
apps' :: (Ord v, Semigroup a) => Term2 vt at ap v a -> [Term2 vt at ap v a] -> Term2 vt at ap v a
iff :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
ann_ :: Ord v => Term0' vt v -> Type vt () -> Term0' vt v
ann :: Ord v => a -> Term2 vt at ap v a -> Type vt at -> Term2 vt at ap v a
lam :: Ord v => a -> (a, v) -> Term2 vt at ap v a -> Term2 vt at ap v a
lam' :: Ord v => a -> [(a, v)] -> Term2 vt at ap v a -> Term2 vt at ap v a
lamWithoutBindingAnns :: Ord v => a -> [v] -> Term2 vt at ap v a -> Term2 vt at ap v a
delay :: Var v => a -> Term2 vt at ap v a -> Term2 vt at ap v a
isLam :: Term2 vt at ap v a -> Bool
arity :: Term2 vt at ap v a -> Int
unLetRecNamedAnnotated :: Term2 vt at ap v a -> Maybe (IsTop, a, [((a, v), Term2 vt at ap v a)], Term2 vt at ap v a)
unLetRecAnnotated :: (Monad m, Var v) => Term2 vt at ap v a -> Maybe (IsTop, (v -> m v) -> m ([((a, v), Term2 vt at ap v a)], Term2 vt at ap v a))
letRec' :: (Ord v, Monoid a) => Bool -> [(v, a, Term' vt v a)] -> Term' vt v a -> Term' vt v a
consLetRec :: Ord v => Bool -> a -> (a, v, Term' vt v a) -> Term' vt v a -> Term' vt v a
letRec :: forall v vt a. Ord v => Bool -> a -> [((a, v), Term' vt v a)] -> Term' vt v a -> Term' vt v a
letRec_ :: Ord v => IsTop -> [(v, Term0' vt v)] -> Term0' vt v -> Term0' vt v
let1_ :: Ord v => IsTop -> [(v, Term0' vt v)] -> Term0' vt v -> Term0' vt v
let1 :: (Ord v, Semigroup a) => IsTop -> [((a, v), Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a
let1' :: (Semigroup a, Ord v) => IsTop -> [(v, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a
singleLet :: Ord v => IsTop -> a -> a -> (v, Term2 vt at ap v a) -> Term2 vt at ap v a -> Term2 vt at ap v a
unLet1 :: Var v => Term' vt v a -> Maybe (IsTop, Term' vt v a, a, Subst (F vt a a) v a)
unLet :: Term2 vt at ap v a -> Maybe ([(IsTop, v, Term2 vt at ap v a)], Term2 vt at ap v a)
unLetRecNamed :: Term2 vt at ap v a -> Maybe (IsTop, [(v, Term2 vt at ap v a)], Term2 vt at ap v a)
unLetRec :: (Monad m, Var v) => Term2 vt at ap v a -> Maybe (IsTop, (v -> m v) -> m ([(v, Term2 vt at ap v a)], Term2 vt at ap v a))
unAnds :: Term2 vt at ap v a -> Maybe ([Term2 vt at ap v a], Term2 vt at ap v a)
unOrs :: Term2 vt at ap v a -> Maybe ([Term2 vt at ap v a], Term2 vt at ap v a)
unApps :: Term2 vt at ap v a -> Maybe (Term2 vt at ap v a, [Term2 vt at ap v a])
unAppsPred :: (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) -> Maybe (Term2 vt at ap v a, [Term2 vt at ap v a])
unBinaryApp :: Term2 vt at ap v a -> Maybe (Term2 vt at ap v a, Term2 vt at ap v a, Term2 vt at ap v a)
unOverappliedBinaryAppPred :: (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) -> Maybe (Term2 vt at ap v a, Term2 vt at ap v a, Term2 vt at ap v a, [Term2 vt at ap v a])
unBinaryApps :: Term2 vt at ap v a -> Maybe ([(Term2 vt at ap v a, Term2 vt at ap v a)], Term2 vt at ap v a)
unBinaryAppsPred :: (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) -> Maybe ([(Term2 vt at ap v a, Term2 vt at ap v a)], Term2 vt at ap v a)
unBinaryAppPred :: (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) -> Maybe (Term2 vt at ap v a, Term2 vt at ap v a, Term2 vt at ap v a)
unLams' :: Term2 vt at ap v a -> Maybe ([v], Term2 vt at ap v a)
unLamsOpt' :: Term2 vt at ap v a -> Maybe ([v], Term2 vt at ap v a)
unLamsUntilDelay' :: Var v => Term2 vt at ap v a -> Maybe ([v], Term2 vt at ap v a)
unLamsPred' :: (Term2 vt at ap v a, v -> Bool) -> Maybe ([v], Term2 vt at ap v a)
unReqOrCtor :: Term2 vt at ap v a -> Maybe ConstructorReference
dependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> DefnsF Set TermReference TypeReference
termDependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> Set TermReference
typeDependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> Set Reference
constructorDependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> Set Reference
generalizedDependencies :: (Ord v, Ord vt, Ord r) => (Reference -> r) -> (Reference -> r) -> (Reference -> r) -> (Reference -> ConstructorId -> r) -> (Reference -> r) -> (Reference -> ConstructorId -> r) -> (Reference -> r) -> Term2 vt at ap v a -> Set r
labeledDependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> Set LabeledDependency
updateDependencies :: Ord v => Map Referent Referent -> Map Reference Reference -> Term v a -> Term v a
betaReduce :: Var v => Term0 v -> Term0 v
betaNormalForm :: Var v => Term0 v -> Term0 v
etaNormalForm :: Ord v => Term0 v -> Term0 v
etaReduceEtaVars :: Var v => Term0 v -> Term0 v
unhashComponent :: Var v => Map Id (Term v a) -> Map Id (v, Term v a)
fromReferent :: Ord v => a -> Referent -> Term2 vt at ap v a
containsExpression :: (Var v, Var typeVar, Eq typeAnn) => Term2 typeVar typeAnn loc v a -> Term2 typeVar typeAnn loc v a -> Bool
containsCaseTerm :: Var v1 => Term2 tv ta tb v1 loc -> Term2 typeVar typeAnn loc v2 a -> Maybe Bool
containsCase :: Pattern loc -> Term2 typeVar typeAnn loc v a -> Bool
containsSignature :: (Ord v, Var vt, Show vt) => Type vt at -> Term2 vt at ap v a -> Bool
rewriteSignatures :: (Ord v, Var vt, Show vt) => Type vt at -> Type vt at -> Term2 vt at ap v a -> Maybe (Term2 vt at ap v a)
rewriteCasesLHS :: (Var v, Var typeVar, Ord v, Show typeVar, Eq typeAnn, Semigroup a) => Term2 typeVar typeAnn a v a -> Term2 typeVar typeAnn a v a -> Term2 typeVar typeAnn a v a -> Maybe (Term2 typeVar typeAnn a v a)
toPattern :: Var v => Term2 tv ta tb v loc -> Maybe (Pattern loc)
matchCaseFromTerm :: Var v => Term2 typeVar typeAnn a v a -> Maybe (MatchCase a (Term2 typeVar typeAnn a v a))
matchCaseToTerm :: (Semigroup a, Ord v) => MatchCase a (Term2 typeVar typeAnn a v a) -> Term2 typeVar typeAnn a v a

Documentation

data MatchCase loc a Source #

Constructors

MatchCase
Fields matchPattern :: Pattern loc matchGuard :: Maybe a matchBody :: a

Instances

Instances details

Generic1 (MatchCase loc :: Type -> Type) Source #

Instance details

Defined in Unison.Term

Associated Types

type Rep1 (MatchCase loc :: Type -> Type)

Instance details

Defined in Unison.Term

type Rep1 (MatchCase loc :: Type -> Type) = D1 ('MetaData "MatchCase" "Unison.Term" "unison-core1-0.0.0-Gff6npkXvgjLEeeiJZVw9w" 'False) (C1 ('MetaCons "MatchCase" 'PrefixI 'True) (S1 ('MetaSel ('Just "matchPattern") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pattern loc)) :*: (S1 ('MetaSel ('Just "matchGuard") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Maybe) :*: S1 ('MetaSel ('Just "matchBody") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1)))

Methods

from1 :: MatchCase loc a -> Rep1 (MatchCase loc) a #

to1 :: Rep1 (MatchCase loc) a -> MatchCase loc a #

Functor (MatchCase loc) Source #

Instance details

Defined in Unison.Term

Methods

fmap :: (a -> b) -> MatchCase loc a -> MatchCase loc b #

(<$) :: a -> MatchCase loc b -> MatchCase loc a #

Foldable (MatchCase loc) Source #

Instance details

Defined in Unison.Term

Methods

fold :: Monoid m => MatchCase loc m -> m #

foldMap :: Monoid m => (a -> m) -> MatchCase loc a -> m #

foldMap' :: Monoid m => (a -> m) -> MatchCase loc a -> m #

foldr :: (a -> b -> b) -> b -> MatchCase loc a -> b #

foldr' :: (a -> b -> b) -> b -> MatchCase loc a -> b #

foldl :: (b -> a -> b) -> b -> MatchCase loc a -> b #

foldl' :: (b -> a -> b) -> b -> MatchCase loc a -> b #

foldr1 :: (a -> a -> a) -> MatchCase loc a -> a #

foldl1 :: (a -> a -> a) -> MatchCase loc a -> a #

toList :: MatchCase loc a -> [a] #

null :: MatchCase loc a -> Bool #

length :: MatchCase loc a -> Int #

elem :: Eq a => a -> MatchCase loc a -> Bool #

maximum :: Ord a => MatchCase loc a -> a #

minimum :: Ord a => MatchCase loc a -> a #

sum :: Num a => MatchCase loc a -> a #

product :: Num a => MatchCase loc a -> a #

Traversable (MatchCase loc) Source #

Instance details

Defined in Unison.Term

Methods

traverse :: Applicative f => (a -> f b) -> MatchCase loc a -> f (MatchCase loc b) #

sequenceA :: Applicative f => MatchCase loc (f a) -> f (MatchCase loc a) #

mapM :: Monad m => (a -> m b) -> MatchCase loc a -> m (MatchCase loc b) #

sequence :: Monad m => MatchCase loc (m a) -> m (MatchCase loc a) #

Generic (MatchCase loc a) Source #

Instance details

Defined in Unison.Term

Associated Types

type Rep (MatchCase loc a)

Instance details

Defined in Unison.Term

type Rep (MatchCase loc a) = D1 ('MetaData "MatchCase" "Unison.Term" "unison-core1-0.0.0-Gff6npkXvgjLEeeiJZVw9w" 'False) (C1 ('MetaCons "MatchCase" 'PrefixI 'True) (S1 ('MetaSel ('Just "matchPattern") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pattern loc)) :*: (S1 ('MetaSel ('Just "matchGuard") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a)) :*: S1 ('MetaSel ('Just "matchBody") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a))))

Methods

from :: MatchCase loc a -> Rep (MatchCase loc a) x #

to :: Rep (MatchCase loc a) x -> MatchCase loc a #

Show a => Show (MatchCase loc a) Source #

Instance details

Defined in Unison.Term

Methods

showsPrec :: Int -> MatchCase loc a -> ShowS #

show :: MatchCase loc a -> String #

showList :: [MatchCase loc a] -> ShowS #

Eq a => Eq (MatchCase loc a) Source #

Instance details

Defined in Unison.Term

Methods

(==) :: MatchCase loc a -> MatchCase loc a -> Bool #

(/=) :: MatchCase loc a -> MatchCase loc a -> Bool #

(Ord loc, Ord a) => Ord (MatchCase loc a) Source #

Instance details

Defined in Unison.Term

Methods

compare :: MatchCase loc a -> MatchCase loc a -> Ordering #

(<) :: MatchCase loc a -> MatchCase loc a -> Bool #

(<=) :: MatchCase loc a -> MatchCase loc a -> Bool #

(>) :: MatchCase loc a -> MatchCase loc a -> Bool #

(>=) :: MatchCase loc a -> MatchCase loc a -> Bool #

max :: MatchCase loc a -> MatchCase loc a -> MatchCase loc a #

min :: MatchCase loc a -> MatchCase loc a -> MatchCase loc a #

type Rep1 (MatchCase loc :: Type -> Type) Source #

Instance details

Defined in Unison.Term

type Rep1 (MatchCase loc :: Type -> Type) = D1 ('MetaData "MatchCase" "Unison.Term" "unison-core1-0.0.0-Gff6npkXvgjLEeeiJZVw9w" 'False) (C1 ('MetaCons "MatchCase" 'PrefixI 'True) (S1 ('MetaSel ('Just "matchPattern") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pattern loc)) :*: (S1 ('MetaSel ('Just "matchGuard") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Maybe) :*: S1 ('MetaSel ('Just "matchBody") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1)))

type Rep (MatchCase loc a) Source #

Instance details

Defined in Unison.Term

type Rep (MatchCase loc a) = D1 ('MetaData "MatchCase" "Unison.Term" "unison-core1-0.0.0-Gff6npkXvgjLEeeiJZVw9w" 'False) (C1 ('MetaCons "MatchCase" 'PrefixI 'True) (S1 ('MetaSel ('Just "matchPattern") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pattern loc)) :*: (S1 ('MetaSel ('Just "matchGuard") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a)) :*: S1 ('MetaSel ('Just "matchBody") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a))))

matchPattern_ :: forall loc a f. Functor f => (Pattern loc -> f (Pattern loc)) -> MatchCase loc a -> f (MatchCase loc a) Source #

data F typeVar typeAnn patternAnn a Source #

Base functor for terms in the Unison language We need typeVar because the term and type variables may differ.

Constructors

Int Int64
Nat Word64
Float Double
Boolean Bool
Text Text
Char Char
Blank (Blank typeAnn)
Ref Reference
Constructor ConstructorReference
Request ConstructorReference
Handle a a
App a a
Ann a (Type typeVar typeAnn)
List (Seq a)
If a a a
And a a
Or a a
Lam a
LetRec IsTop [a] a
Let IsTop a a
Match a [MatchCase patternAnn a]
TermLink Referent
TypeLink Reference
Record (Map Text a)	Field names carry no annotation of their own, so errors about a field are reported at the field value's location.
RecordSet Text a a	`RecordSet fieldName record newValue`: `record` with one field's value replaced. The field must already exist, and the result has the record's own field set (and so its shape at runtime).
RecordSetBlock [Text] [(Text, a)] a	`RecordSetBlock path fields target`: the record `target`, reached by following `path` (a chain of field names), with the fields in `fields` replaced, in the order given. `target@path@{f: e, ...}`. Each field's value is abstracted over the record being updated (a variable named `recordSetTargetName`), so that the binder is present for every pass over the term and not only for typechecking. A value reads a field's current value as `@field`, which is a projection on that variable; a bare name in a value means whatever it means outside the block. This is sugar: it is expanded to a match over a chain of `RecordSet`s when it is typechecked and when it is compiled to runtime form (`expandRecordSetBlock`). It survives in the term so that it prints back as the source form.

Instances

Instances details

Generic1 (F typeVar typeAnn patternAnn :: Type -> Type) Source #

Instance details

Defined in Unison.Term

Associated Types

type Rep1 (F typeVar typeAnn patternAnn :: Type -> Type)

Instance details

Defined in Unison.Term

Methods

from1 :: F typeVar typeAnn patternAnn a -> Rep1 (F typeVar typeAnn patternAnn) a #

to1 :: Rep1 (F typeVar typeAnn patternAnn) a -> F typeVar typeAnn patternAnn a #

Functor (F typeVar typeAnn patternAnn) Source #

Instance details

Defined in Unison.Term

Methods

fmap :: (a -> b) -> F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn b #

(<$) :: a -> F typeVar typeAnn patternAnn b -> F typeVar typeAnn patternAnn a #

Foldable (F typeVar typeAnn patternAnn) Source #

Instance details

Defined in Unison.Term

Methods

fold :: Monoid m => F typeVar typeAnn patternAnn m -> m #

foldMap :: Monoid m => (a -> m) -> F typeVar typeAnn patternAnn a -> m #

foldMap' :: Monoid m => (a -> m) -> F typeVar typeAnn patternAnn a -> m #

foldr :: (a -> b -> b) -> b -> F typeVar typeAnn patternAnn a -> b #

foldr' :: (a -> b -> b) -> b -> F typeVar typeAnn patternAnn a -> b #

foldl :: (b -> a -> b) -> b -> F typeVar typeAnn patternAnn a -> b #

foldl' :: (b -> a -> b) -> b -> F typeVar typeAnn patternAnn a -> b #

foldr1 :: (a -> a -> a) -> F typeVar typeAnn patternAnn a -> a #

foldl1 :: (a -> a -> a) -> F typeVar typeAnn patternAnn a -> a #

toList :: F typeVar typeAnn patternAnn a -> [a] #

null :: F typeVar typeAnn patternAnn a -> Bool #

length :: F typeVar typeAnn patternAnn a -> Int #

elem :: Eq a => a -> F typeVar typeAnn patternAnn a -> Bool #

maximum :: Ord a => F typeVar typeAnn patternAnn a -> a #

minimum :: Ord a => F typeVar typeAnn patternAnn a -> a #

sum :: Num a => F typeVar typeAnn patternAnn a -> a #

product :: Num a => F typeVar typeAnn patternAnn a -> a #

Traversable (F typeVar typeAnn patternAnn) Source #

Instance details

Defined in Unison.Term

Methods

traverse :: Applicative f => (a -> f b) -> F typeVar typeAnn patternAnn a -> f (F typeVar typeAnn patternAnn b) #

sequenceA :: Applicative f => F typeVar typeAnn patternAnn (f a) -> f (F typeVar typeAnn patternAnn a) #

mapM :: Monad m => (a -> m b) -> F typeVar typeAnn patternAnn a -> m (F typeVar typeAnn patternAnn b) #

sequence :: Monad m => F typeVar typeAnn patternAnn (m a) -> m (F typeVar typeAnn patternAnn a) #

Generic (F typeVar typeAnn patternAnn a) Source #

Instance details

Defined in Unison.Term

Associated Types

type Rep (F typeVar typeAnn patternAnn a)

Instance details

Defined in Unison.Term

Methods

from :: F typeVar typeAnn patternAnn a -> Rep (F typeVar typeAnn patternAnn a) x #

to :: Rep (F typeVar typeAnn patternAnn a) x -> F typeVar typeAnn patternAnn a #

(Show v, Show a) => Show (F v a0 p a) Source #

Instance details

Defined in Unison.Term

Methods

showsPrec :: Int -> F v a0 p a -> ShowS #

show :: F v a0 p a -> String #

showList :: [F v a0 p a] -> ShowS #

(Var vt, Eq at, Eq a) => Eq (F vt at p a) Source #

Instance details

Defined in Unison.Term

Methods

(==) :: F vt at p a -> F vt at p a -> Bool #

(/=) :: F vt at p a -> F vt at p a -> Bool #

(Var typeVar, Ord typeAnn, Ord patternAnn, Ord a) => Ord (F typeVar typeAnn patternAnn a) Source #

Instance details

Defined in Unison.Term

Methods

compare :: F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn a -> Ordering #

(<) :: F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn a -> Bool #

(<=) :: F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn a -> Bool #

(>) :: F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn a -> Bool #

(>=) :: F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn a -> Bool #

max :: F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn a #

min :: F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn a -> F typeVar typeAnn patternAnn a #

type Rep1 (F typeVar typeAnn patternAnn :: Type -> Type) Source #

Instance details

Defined in Unison.Term

type Rep (F typeVar typeAnn patternAnn a) Source #

Instance details

Defined in Unison.Term

recordSetTargetName :: Text Source #

The variable a record-set block binds to the record being updated, which its values mention to read a field (`@field` is a projection on it). Deliberately unlikely rather than unforgeable: unlike the typechecker's markers it reaches the printer, which parses variable names, so it has to be a name the lexer accepts.

_Ref :: forall tv ta pa a p f. (Choice p, Applicative f) => p Reference (f Reference) -> p (F tv ta pa a) (f (F tv ta pa a)) Source #

_Match :: forall tv ta pa a p f. (Choice p, Applicative f) => p (a, [MatchCase pa a]) (f (a, [MatchCase pa a])) -> p (F tv ta pa a) (f (F tv ta pa a)) Source #

_Constructor :: forall tv ta pa a p f. (Choice p, Applicative f) => p ConstructorReference (f ConstructorReference) -> p (F tv ta pa a) (f (F tv ta pa a)) Source #

_Request :: forall tv ta pa a p f. (Choice p, Applicative f) => p ConstructorReference (f ConstructorReference) -> p (F tv ta pa a) (f (F tv ta pa a)) Source #

_Ann :: forall tv ta pa a p f. (Choice p, Applicative f) => p (a, Term F tv ta) (f (a, Term F tv ta)) -> p (F tv ta pa a) (f (F tv ta pa a)) Source #

_TermLink :: forall tv ta pa a p f. (Choice p, Applicative f) => p Referent (f Referent) -> p (F tv ta pa a) (f (F tv ta pa a)) Source #

_TypeLink :: forall tv ta pa a p f. (Choice p, Applicative f) => p Reference (f Reference) -> p (F tv ta pa a) (f (F tv ta pa a)) Source #

getTypeAnnotation :: Term v a -> Maybe (Type v a) Source #

Returns the top-level type annotation for a term if it has one.

type IsTop = Bool Source #

type Term v a = Term2 v a a v a Source #

Like `Term v`, but with an annotation of type a at every level in the tree

type Term' vt v a = Term2 vt a a v a Source #

Allow type variables and term variables to differ

type Term2 vt at ap v a = Term (F vt at ap) v a Source #

Allow type variables, term variables, type annotations and term annotations to all differ

type Term3 v a = Term2 v () () v a Source #

Like `Term v a`, but with only () for type and pattern annotations.

type Term0 v = Term v () Source #

Terms are represented as ABTs over the base functor F, with variables in v

type Term0' vt v = Term' vt v () Source #

Terms with type variables in vt, and term variables in v

bindNames :: Var v => (v -> Name) -> (Name -> v) -> Set v -> Names -> Term v a -> ResolutionResult a (Term v a) Source #

prepareTDNR :: Var v => Term (F vt b ap) v b -> Term (F vt b ap) v b Source #

amap :: Ord v => (a -> a2) -> Term v a -> Term v a2 Source #

patternMap :: (Pattern ap -> Pattern ap2) -> Term2 vt at ap v a -> Term2 vt at ap2 v a Source #

vmap :: Ord v2 => (v -> v2) -> Term v a -> Term v2 a Source #

vtmap :: Ord vt2 => (vt -> vt2) -> Term' vt v a -> Term' vt2 v a Source #

typeMap :: Ord vt2 => (Type vt at -> Type vt2 at2) -> Term2 vt at ap v a -> Term2 vt2 at2 ap v a Source #

extraMap' :: (Ord vt, Ord vt') => (vt -> vt') -> (at -> at') -> (ap -> ap') -> Term2 vt at ap v a -> Term2 vt' at' ap' v a Source #

extraMap :: (Ord vt, Ord vt') => (vt -> vt') -> (at -> at') -> (ap -> ap') -> F vt at ap a -> F vt' at' ap' a Source #

matchCaseExtraMap :: (loc -> loc') -> MatchCase loc a -> MatchCase loc' a Source #

unannotate :: forall vt at ap v a. Ord v => Term2 vt at ap v a -> Term0' vt v Source #

wrapV :: Ord v => Term v a -> Term (V v) a Source #

allVars :: Ord v => Term v a -> Set v Source #

All variables mentioned in the given term. Includes both term and type variables, both free and bound.

freeVars :: Term' vt v a -> Set v Source #

freeTypeVars :: Ord vt => Term' vt v a -> Set vt Source #

freeTypeVarAnnotations :: Ord vt => Term' vt v a -> Map vt [a] Source #

substTypeVars :: (Ord v, Var vt) => [(vt, Type vt b)] -> Term' vt v a -> Term' vt v a Source #

substTypeVar :: (Ord v, Var vt) => vt -> Type vt b -> Term' vt v a -> Term' vt v a Source #

renameTypeVar :: (Ord v, Var vt) => vt -> vt -> Term' vt v a -> Term' vt v a Source #

generalizeTypeSignatures :: (Var vt, Var v) => Term' vt v a -> Term' vt v a Source #

pattern Var' :: v -> Term f v a Source #

pattern Cycle' :: [v] -> f (Term f v a) -> Term f v a Source #

pattern Abs' :: (Foldable f, Functor f, Var v) => Subst f v a -> Term f v a Source #

pattern Int' :: Int64 -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Nat' :: Word64 -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Float' :: Double -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Boolean' :: Bool -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Text' :: Text -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Char' :: Char -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Blank' :: Blank typeAnn -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Ref' :: Reference -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern TermLink' :: Referent -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern TypeLink' :: Reference -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Builtin' :: Text -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern App' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Match' :: Term (F typeVar typeAnn patternAnn) v a -> [MatchCase patternAnn (Term (F typeVar typeAnn patternAnn) v a)] -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Constructor' :: ConstructorReference -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Record' :: Map Text (Term (F typeVar typeAnn patternAnn) v a) -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern RecordSet' :: Text -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

RecordSet' field record newValue: record with field replaced.

pattern RecordSetBlock' :: [Text] -> [(Text, Term (F typeVar typeAnn patternAnn) v a)] -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

RecordSetBlock' path fields target is target@path@{f: e, ...}: see RecordSetBlock.

pattern Request' :: ConstructorReference -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern RequestOrCtor' :: ConstructorReference -> Term2 vt at ap v a Source #

pattern If' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern And' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Or' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Handle' :: Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Apps' :: Term2 vt at ap v a -> [Term2 vt at ap v a] -> Term2 vt at ap v a Source #

pattern Ands' :: [Term2 vt at ap v a] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern Ors' :: [Term2 vt at ap v a] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern AppsPred' :: Term2 vt at ap v a -> [Term2 vt at ap v a] -> (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) Source #

pattern BinaryApp' :: Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern BinaryApps' :: [(Term2 vt at ap v a, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern BinaryAppsPred' :: [(Term2 vt at ap v a, Term2 vt at ap v a)] -> Term2 vt at ap v a -> (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) Source #

pattern BinaryAppPred' :: Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a -> (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) Source #

pattern OverappliedBinaryAppPred' :: Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a -> [Term2 vt at ap v a] -> (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) Source #

pattern Ann' :: Term (F typeVar typeAnn patternAnn) v a -> Type typeVar typeAnn -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern List' :: Seq (Term (F typeVar typeAnn patternAnn) v a) -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Lam' :: Var v => a -> Subst (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Delay' :: Var v => Term2 vt at ap v a -> Term2 vt at ap v a Source #

unDelay :: Var v => Term2 vt at ap v a -> Maybe (Term2 vt at ap v a) Source #

pattern LamNamed' :: v -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern LamsNamed' :: [v] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern LamsNamedOpt' :: [v] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern LamsNamedPred' :: [v] -> Term2 vt at ap v a -> (Term2 vt at ap v a, v -> Bool) Source #

pattern LamsNamedOrDelay' :: Var v => [v] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern Let1' :: Var v => Term' vt v a -> a -> Subst (F vt a a) v a -> Term' vt v a Source #

pattern Let1Top' :: Var v => IsTop -> Term' vt v a -> a -> Subst (F vt a a) v a -> Term' vt v a Source #

pattern Let1Named' :: v -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Let1NamedTop' :: IsTop -> v -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a -> Term (F typeVar typeAnn patternAnn) v a Source #

pattern Lets' :: [(IsTop, v, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern LetRecNamed' :: [(v, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern LetRecNamedTop' :: IsTop -> [(v, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

pattern LetRec' :: (Monad m, Var v) => ((v -> m v) -> m ([(v, Term2 vt at ap v a)], Term2 vt at ap v a)) -> Term2 vt at ap v a Source #

pattern LetRecTop' :: (Monad m, Var v) => IsTop -> ((v -> m v) -> m ([(v, Term2 vt at ap v a)], Term2 vt at ap v a)) -> Term2 vt at ap v a Source #

pattern LetRecAnnotatedTop' :: (Monad m, Var v) => IsTop -> ((v -> m v) -> m ([((a, v), Term2 vt at ap v a)], Term2 vt at ap v a)) -> Term2 vt at ap v a Source #

pattern LetRecNamedAnnotated' :: a -> [((a, v), Term' vt v a)] -> Term' vt v a -> Term' vt v a Source #

pattern LetRecNamedAnnotatedTop' :: IsTop -> a -> [((a, v), Term' vt v a)] -> Term' vt v a -> Term' vt v a Source #

fresh :: Var v => Term0 v -> v -> v Source #

var :: a -> v -> Term2 vt at ap v a Source #

var' :: Var v => Text -> Term0' vt v Source #

ref :: Ord v => a -> Reference -> Term2 vt at ap v a Source #

pattern Referent' :: Referent -> Term2 vt at ap v a Source #

unReferent :: Term2 vt at ap v a -> Maybe Referent Source #

refId :: Ord v => a -> Id -> Term2 vt at ap v a Source #

termLink :: Ord v => a -> Referent -> Term2 vt at ap v a Source #

typeLink :: Ord v => a -> Reference -> Term2 vt at ap v a Source #

builtin :: Ord v => a -> Text -> Term2 vt at ap v a Source #

float :: Ord v => a -> Double -> Term2 vt at ap v a Source #

boolean :: Ord v => a -> Bool -> Term2 vt at ap v a Source #

int :: Ord v => a -> Int64 -> Term2 vt at ap v a Source #

nat :: Ord v => a -> Word64 -> Term2 vt at ap v a Source #

text :: Ord v => a -> Text -> Term2 vt at ap v a Source #

char :: Ord v => a -> Char -> Term2 vt at ap v a Source #

watch :: (Var v, Semigroup a) => a -> String -> Term v a -> Term v a Source #

watchMaybe :: (Var v, Semigroup a) => Maybe String -> Term v a -> Term v a Source #

blank :: Ord v => a -> Term2 vt at ap v a Source #

placeholder :: Ord v => a -> String -> Term2 vt a ap v a Source #

resolve :: Ord v => at -> ab -> String -> Term2 vt ab ap v at Source #

missingResult :: Ord v => at -> ab -> Term2 vt ab ap v at Source #

constructor :: Ord v => a -> ConstructorReference -> Term2 vt at ap v a Source #

request :: Ord v => a -> ConstructorReference -> Term2 vt at ap v a Source #

record :: Ord v => a -> Map Text (Term2 vt at ap v a) -> Term2 vt at ap v a Source #

recordSet :: Ord v => a -> Text -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

recordSet a field r v is r with field replaced by v.

recordSetBlock :: (Ord vt, Ord v) => a -> [Text] -> [(Text, Term2 vt at a v a)] -> Term2 vt at a v a -> Term2 vt at a v a Source #

recordSetBlock a path fields target is target@path@{f: e, ...}: see RecordSetBlock. Expanded by expandRecordSetBlock.

recordProjection :: (Ord vt, Ord v, Var v) => a -> a -> Term2 vt at a v a -> Text -> Term2 vt at a v a Source #

base@field desugars to a single-field record match.

That needs no new term form: it typechecks to {field: t | row} -> t through the existing record pattern machinery (the row is left a variable, so further projections on the same value can still learn about other fields), and it compiles to the existing RecUnpack instruction. The bound variable scopes over nothing but itself, so it cannot capture and needs no freshening.

The first argument annotates the field, which is the innermost location: the parser passes the field token's annotation.

expandRecordSetBlock :: (Ord vt, Ord v, Var v) => Term2 vt at a v a -> Term2 vt at a v a Source #

Expand a record-set block, target@path@{f: e, ...}, into the term it means:

let r = target
    f1 = r@f1
    f2 = r@f2
in (r@f1.set e1)@f2.set e2

The target is bound once, so it is evaluated exactly once however many fields the block sets and however deep the path is, and the block's field names are bound to the record's *old* field values by projecting them out of that binding. The sets are then chained left to right, so each replaces a field on the result of the previous one, at both the term and the type level.

Nothing here is a record pattern, deliberately: a pattern creates field existentials in one scope, and the sets would then be comparing against them from another scope, which the ordered context does not permit. Reading the old values with projections keeps every constraint between a set's own variable and a variable introduced *after* it. The intermediate records named by path are freshened against every free variable in the block, since they scope over user code.

app_ :: Ord v => Term0' vt v -> Term0' vt v -> Term0' vt v Source #

app :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

match :: Ord v => a -> Term2 vt at a v a -> [MatchCase a (Term2 vt at a v a)] -> Term2 vt at a v a Source #

handle :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

and :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

or :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

list :: Ord v => a -> [Term2 vt at ap v a] -> Term2 vt at ap v a Source #

list' :: Ord v => a -> Seq (Term2 vt at ap v a) -> Term2 vt at ap v a Source #

apps :: Ord v => Term2 vt at ap v a -> [(a, Term2 vt at ap v a)] -> Term2 vt at ap v a Source #

apps' :: (Ord v, Semigroup a) => Term2 vt at ap v a -> [Term2 vt at ap v a] -> Term2 vt at ap v a Source #

iff :: Ord v => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

ann_ :: Ord v => Term0' vt v -> Type vt () -> Term0' vt v Source #

ann :: Ord v => a -> Term2 vt at ap v a -> Type vt at -> Term2 vt at ap v a Source #

lam Source #

Arguments

:: Ord v
=> a	Annotation of the whole lambda
-> (a, v)
-> Term2 vt at ap v a
-> Term2 vt at ap v a

Add a lambda with a single argument.

lam' Source #

Arguments

:: Ord v
=> a	Annotation of the whole lambda
-> [(a, v)]
-> Term2 vt at ap v a
-> Term2 vt at ap v a

Add a lambda with a list of arguments.

lamWithoutBindingAnns :: Ord v => a -> [v] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

Only use this variant if you don't have source annotations for the binding arguments available.

delay :: Var v => a -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

isLam :: Term2 vt at ap v a -> Bool Source #

arity :: Term2 vt at ap v a -> Int Source #

unLetRecNamedAnnotated :: Term2 vt at ap v a -> Maybe (IsTop, a, [((a, v), Term2 vt at ap v a)], Term2 vt at ap v a) Source #

unLetRecAnnotated :: (Monad m, Var v) => Term2 vt at ap v a -> Maybe (IsTop, (v -> m v) -> m ([((a, v), Term2 vt at ap v a)], Term2 vt at ap v a)) Source #

letRec' :: (Ord v, Monoid a) => Bool -> [(v, a, Term' vt v a)] -> Term' vt v a -> Term' vt v a Source #

consLetRec :: Ord v => Bool -> a -> (a, v, Term' vt v a) -> Term' vt v a -> Term' vt v a Source #

letRec :: forall v vt a. Ord v => Bool -> a -> [((a, v), Term' vt v a)] -> Term' vt v a -> Term' vt v a Source #

letRec_ :: Ord v => IsTop -> [(v, Term0' vt v)] -> Term0' vt v -> Term0' vt v Source #

Smart constructor for let rec blocks. Each binding in the block may reference any other binding in the block in its body (including itself), and the output expression may also reference any binding in the block.

let1_ :: Ord v => IsTop -> [(v, Term0' vt v)] -> Term0' vt v -> Term0' vt v Source #

Smart constructor for let blocks. Each binding in the block may reference only previous bindings in the block, not including itself. The output expression may reference any binding in the block. todo: delete me

let1 :: (Ord v, Semigroup a) => IsTop -> [((a, v), Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

annotations are applied to each nested Let expression

let1' :: (Semigroup a, Ord v) => IsTop -> [(v, Term2 vt at ap v a)] -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

singleLet :: Ord v => IsTop -> a -> a -> (v, Term2 vt at ap v a) -> Term2 vt at ap v a -> Term2 vt at ap v a Source #

Like let1, but for a single binding, avoiding the Semigroup constraint.

unLet1 :: Var v => Term' vt v a -> Maybe (IsTop, Term' vt v a, a, Subst (F vt a a) v a) Source #

unLet :: Term2 vt at ap v a -> Maybe ([(IsTop, v, Term2 vt at ap v a)], Term2 vt at ap v a) Source #

Satisfies `unLet (let' bs e) == Just (bs, e)`

unLetRecNamed :: Term2 vt at ap v a -> Maybe (IsTop, [(v, Term2 vt at ap v a)], Term2 vt at ap v a) Source #

Satisfies `unLetRec (letRec bs e) == Just (bs, e)`

unLetRec :: (Monad m, Var v) => Term2 vt at ap v a -> Maybe (IsTop, (v -> m v) -> m ([(v, Term2 vt at ap v a)], Term2 vt at ap v a)) Source #

unAnds :: Term2 vt at ap v a -> Maybe ([Term2 vt at ap v a], Term2 vt at ap v a) Source #

unOrs :: Term2 vt at ap v a -> Maybe ([Term2 vt at ap v a], Term2 vt at ap v a) Source #

unApps :: Term2 vt at ap v a -> Maybe (Term2 vt at ap v a, [Term2 vt at ap v a]) Source #

unAppsPred :: (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) -> Maybe (Term2 vt at ap v a, [Term2 vt at ap v a]) Source #

unBinaryApp :: Term2 vt at ap v a -> Maybe (Term2 vt at ap v a, Term2 vt at ap v a, Term2 vt at ap v a) Source #

unOverappliedBinaryAppPred :: (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) -> Maybe (Term2 vt at ap v a, Term2 vt at ap v a, Term2 vt at ap v a, [Term2 vt at ap v a]) Source #

unBinaryApps :: Term2 vt at ap v a -> Maybe ([(Term2 vt at ap v a, Term2 vt at ap v a)], Term2 vt at ap v a) Source #

unBinaryAppsPred :: (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) -> Maybe ([(Term2 vt at ap v a, Term2 vt at ap v a)], Term2 vt at ap v a) Source #

unBinaryAppPred :: (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) -> Maybe (Term2 vt at ap v a, Term2 vt at ap v a, Term2 vt at ap v a) Source #

unLams' :: Term2 vt at ap v a -> Maybe ([v], Term2 vt at ap v a) Source #

unLamsOpt' :: Term2 vt at ap v a -> Maybe ([v], Term2 vt at ap v a) Source #

unLamsUntilDelay' :: Var v => Term2 vt at ap v a -> Maybe ([v], Term2 vt at ap v a) Source #

unLamsPred' :: (Term2 vt at ap v a, v -> Bool) -> Maybe ([v], Term2 vt at ap v a) Source #

unReqOrCtor :: Term2 vt at ap v a -> Maybe ConstructorReference Source #

dependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> DefnsF Set TermReference TypeReference Source #

termDependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> Set TermReference Source #

typeDependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> Set Reference Source #

constructorDependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> Set Reference Source #

generalizedDependencies :: (Ord v, Ord vt, Ord r) => (Reference -> r) -> (Reference -> r) -> (Reference -> r) -> (Reference -> ConstructorId -> r) -> (Reference -> r) -> (Reference -> ConstructorId -> r) -> (Reference -> r) -> Term2 vt at ap v a -> Set r Source #

labeledDependencies :: (Ord v, Ord vt) => Term2 vt at ap v a -> Set LabeledDependency Source #

updateDependencies :: Ord v => Map Referent Referent -> Map Reference Reference -> Term v a -> Term v a Source #

betaReduce :: Var v => Term0 v -> Term0 v Source #

If the outermost term is a function application, perform substitution of the argument into the body

betaNormalForm :: Var v => Term0 v -> Term0 v Source #

etaNormalForm :: Ord v => Term0 v -> Term0 v Source #

etaReduceEtaVars :: Var v => Term0 v -> Term0 v Source #

unhashComponent :: Var v => Map Id (Term v a) -> Map Id (v, Term v a) Source #

fromReferent :: Ord v => a -> Referent -> Term2 vt at ap v a Source #

containsExpression :: (Var v, Var typeVar, Eq typeAnn) => Term2 typeVar typeAnn loc v a -> Term2 typeVar typeAnn loc v a -> Bool Source #

containsCaseTerm :: Var v1 => Term2 tv ta tb v1 loc -> Term2 typeVar typeAnn loc v2 a -> Maybe Bool Source #

containsCase :: Pattern loc -> Term2 typeVar typeAnn loc v a -> Bool Source #

containsSignature :: (Ord v, Var vt, Show vt) => Type vt at -> Term2 vt at ap v a -> Bool Source #

rewriteSignatures :: (Ord v, Var vt, Show vt) => Type vt at -> Type vt at -> Term2 vt at ap v a -> Maybe (Term2 vt at ap v a) Source #

rewriteCasesLHS :: (Var v, Var typeVar, Ord v, Show typeVar, Eq typeAnn, Semigroup a) => Term2 typeVar typeAnn a v a -> Term2 typeVar typeAnn a v a -> Term2 typeVar typeAnn a v a -> Maybe (Term2 typeVar typeAnn a v a) Source #

toPattern :: Var v => Term2 tv ta tb v loc -> Maybe (Pattern loc) Source #

matchCaseFromTerm :: Var v => Term2 typeVar typeAnn a v a -> Maybe (MatchCase a (Term2 typeVar typeAnn a v a)) Source #

matchCaseToTerm :: (Semigroup a, Ord v) => MatchCase a (Term2 typeVar typeAnn a v a) -> Term2 typeVar typeAnn a v a Source #