A let expression can be written either as let x = e1 in e2 or as def x = e1 end; e2. This enumeration simply records which it was so that we can pretty-print appropriately.

Constructors

LSLet
LSDef

Instances

Instances details

FromJSON LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

parseJSON :: Value -> Parser LetSyntax #

parseJSONList :: Value -> Parser [LetSyntax] #

omittedField :: Maybe LetSyntax #

ToJSON LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

toJSON :: LetSyntax -> Value #

toEncoding :: LetSyntax -> Encoding #

toJSONList :: [LetSyntax] -> Value #

toEncodingList :: [LetSyntax] -> Encoding #

omitField :: LetSyntax -> Bool #

Data LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LetSyntax -> c LetSyntax #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LetSyntax #

toConstr :: LetSyntax -> Constr #

dataTypeOf :: LetSyntax -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LetSyntax) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetSyntax) #

gmapT :: (forall b. Data b => b -> b) -> LetSyntax -> LetSyntax #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LetSyntax -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LetSyntax -> r #

gmapQ :: (forall d. Data d => d -> u) -> LetSyntax -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LetSyntax -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LetSyntax -> m LetSyntax #

Bounded LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

minBound :: LetSyntax #

maxBound :: LetSyntax #

Enum LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

succ :: LetSyntax -> LetSyntax #

pred :: LetSyntax -> LetSyntax #

toEnum :: Int -> LetSyntax #

fromEnum :: LetSyntax -> Int #

enumFrom :: LetSyntax -> [LetSyntax] #

enumFromThen :: LetSyntax -> LetSyntax -> [LetSyntax] #

enumFromTo :: LetSyntax -> LetSyntax -> [LetSyntax] #

enumFromThenTo :: LetSyntax -> LetSyntax -> LetSyntax -> [LetSyntax] #

Generic LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Associated Types

type Rep LetSyntax
Instance details Defined in Swarm.Language.Syntax.AST type Rep LetSyntax = D1 ('MetaData "LetSyntax" "Swarm.Language.Syntax.AST" "swarm-0.7.0.0-IuFfgHrMoE7JrptOBRVOwx-swarm-lang" 'False) (C1 ('MetaCons "LSLet" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LSDef" 'PrefixI 'False) (U1 :: Type -> Type))

Methods

from :: LetSyntax -> Rep LetSyntax x #

to :: Rep LetSyntax x -> LetSyntax #

Show LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

showsPrec :: Int -> LetSyntax -> ShowS #

show :: LetSyntax -> String #

showList :: [LetSyntax] -> ShowS #

Eq LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

(==) :: LetSyntax -> LetSyntax -> Bool #

(/=) :: LetSyntax -> LetSyntax -> Bool #

Ord LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

compare :: LetSyntax -> LetSyntax -> Ordering #

(<) :: LetSyntax -> LetSyntax -> Bool #

(<=) :: LetSyntax -> LetSyntax -> Bool #

(>) :: LetSyntax -> LetSyntax -> Bool #

(>=) :: LetSyntax -> LetSyntax -> Bool #

max :: LetSyntax -> LetSyntax -> LetSyntax #

min :: LetSyntax -> LetSyntax -> LetSyntax #

Hashable LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

hashWithSalt :: Int -> LetSyntax -> Int #

hash :: LetSyntax -> Int #

type Rep LetSyntax Source #

Instance details

Defined in Swarm.Language.Syntax.AST

type Rep LetSyntax = D1 ('MetaData "LetSyntax" "Swarm.Language.Syntax.AST" "swarm-0.7.0.0-IuFfgHrMoE7JrptOBRVOwx-swarm-lang" 'False) (C1 ('MetaCons "LSLet" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LSDef" 'PrefixI 'False) (U1 :: Type -> Type))

data Term' ty Source #

Terms of the Swarm language.

Constructors

TUnit	The unit value.
TConst Const	A constant.
TDir Direction	A direction literal.
TInt Integer	An integer literal.
TAntiInt Text	An antiquoted Haskell variable name of type Integer.
TText Text	A text literal.
TAntiText Text	An antiquoted Haskell variable name of type Text.
TBool Bool	A Boolean literal.
TAntiSyn Text	An antiquoted Haskell variable name of type Syntax.
TRobot Int	A robot reference. These never show up in surface syntax, but are here so we can factor pretty-printing for Values through pretty-printing for Terms.
TRef Int	A memory reference. These likewise never show up in surface syntax, but are here to facilitate pretty-printing.
TRequire Text	Require a specific device to be installed.
TStock Int Text	Require a certain number of an entity.
SRequirements Text (Syntax' ty)	Primitive command to log requirements of a term. The Text field is to store the unaltered original text of the term, for use in displaying the log message (since once we get to execution time the original term may have been elaborated, e.g. `force` may have been added around some variables, etc.)
TVar Var	A variable.
SPair (Syntax' ty) (Syntax' ty)	A pair.
SLam LocVar (Maybe Type) (Syntax' ty)	A lambda expression, with or without a type annotation on the binder.
SApp (Syntax' ty) (Syntax' ty)	Function application.
SLet LetSyntax Bool LocVar (Maybe RawPolytype) (Maybe Polytype) (Maybe Requirements) (Syntax' ty) (Syntax' ty)	A (recursive) let/def expression, with or without a type annotation on the variable. The `Bool` indicates whether it is known to be recursive. The `Maybe Polytype` and `Maybe Requirements` fields are only for annotating the requirements of a definition after typechecking; there is no way to annotate requirements in the surface syntax.
STydef (Located TDVar) Polytype (Maybe TydefInfo) (Syntax' ty)	A type synonym definition. Note that this acts like a `let` (just like `def`), i.e. the `Syntax' ty` field is the local context over which the type definition is in scope.
SBind (Maybe LocVar) (Maybe ty) (Maybe Polytype) (Maybe Requirements) (Syntax' ty) (Syntax' ty)	A monadic bind for commands, of the form `c1 ; c2` or `x <- c1; c2`. The `Maybe ty` field is a place to stash the inferred type of the variable (if any) during type inference. Once type inference is complete, during elaboration we will copy the inferred type into the `Maybe Polytype` field (since the `Maybe ty` field will be erased). The `Maybe Polytype` and `Maybe Requirements` fields is only for annotating the type of a bind after typechecking; there is no surface syntax that allows directly annotating a bind with either one.
SDelay (Syntax' ty)	Delay evaluation of a term, written `{...}`. Swarm is an eager language, but in some cases (e.g. for `if` statements and recursive bindings) we need to delay evaluation. The counterpart to `{...}` is `force`, where `force {t} = t`. Note that `Force` is just a constant, whereas `SDelay` has to be a special syntactic form so its argument can get special treatment during evaluation.
SRcd (Map Var (Maybe (Syntax' ty)))	Record literals `[x1 = e1, x2 = e2, x3, ...]` Names `x` without an accompanying definition are sugar for writing `x=x`.
SProj (Syntax' ty) Var	Record projection `e.x`
SAnnotate (Syntax' ty) RawPolytype	Annotate a term with a type
SSuspend (Syntax' ty)	Run the given command, then suspend and wait for a new REPL input.
SParens (Syntax' ty)	An explicit representation of parentheses in the input. We need this to be able to print formatted code with parentheses and comments preserved, but we get rid of them during elaboration.
TType Type	A type literal.

Instances

Instances details

FromJSON Term Source #

Instance details

Defined in Swarm.Language.JSON

Methods

parseJSON :: Value -> Parser Term #

parseJSONList :: Value -> Parser [Term] #

omittedField :: Maybe Term #

ToJSON Term Source #

Instance details

Defined in Swarm.Language.JSON

Methods

toJSON :: Term -> Value #

toEncoding :: Term -> Encoding #

toJSONList :: [Term] -> Value #

toEncodingList :: [Term] -> Encoding #

omitField :: Term -> Bool #

Foldable Term' Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

fold :: Monoid m => Term' m -> m #

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

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

foldr :: (a -> b -> b) -> b -> Term' a -> b #

foldr' :: (a -> b -> b) -> b -> Term' a -> b #

foldl :: (b -> a -> b) -> b -> Term' a -> b #

foldl' :: (b -> a -> b) -> b -> Term' a -> b #

foldr1 :: (a -> a -> a) -> Term' a -> a #

foldl1 :: (a -> a -> a) -> Term' a -> a #

toList :: Term' a -> [a] #

null :: Term' a -> Bool #

length :: Term' a -> Int #

elem :: Eq a => a -> Term' a -> Bool #

maximum :: Ord a => Term' a -> a #

minimum :: Ord a => Term' a -> a #

sum :: Num a => Term' a -> a #

product :: Num a => Term' a -> a #

Traversable Term' Source #

The Traversable instance for Term (and for Syntax') is used during typechecking: during intermediate type inference, many of the type annotations placed on AST nodes will have unification variables in them. Once we have finished solving everything we need to do a final traversal over all the types in the AST to substitute away all the unification variables (and generalize, i.e. stick forall on, as appropriate). See the call to mapM in Swarm.Language.Typecheck.runInfer.

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

traverse :: Applicative f => (a -> f b) -> Term' a -> f (Term' b) #

sequenceA :: Applicative f => Term' (f a) -> f (Term' a) #

mapM :: Monad m => (a -> m b) -> Term' a -> m (Term' b) #

sequence :: Monad m => Term' (m a) -> m (Term' a) #

Functor Term' Source #

Instance details

Defined in Swarm.Language.Syntax.AST

Methods

fmap :: (a -> b) -> Term' a -> Term' b #