Swarm.Language.Syntax

Abstract syntax for terms of the Swarm programming language.

Constants

data Const

Constants, representing various built-in functions and commands.

IF YOU ADD A NEW CONSTANT, be sure to also update: 1. the constInfo function (below) 2. the capability checker (Swarm.Language.Capability) 3. the type checker (Swarm.Language.Typecheck) 4. the runtime (Swarm.Game.Step) 5. the emacs mode syntax highlighter (contribs/swarm-mode.el)

GHC will warn you about incomplete pattern matches for the first four, and CI will warn you about the last, so in theory it's not really possible to forget. Note you do not need to update the parser or pretty-printer, since they are auto-generated from constInfo.

Constructors

Noop

Do nothing. This is different than Wait in that it does not take up a time step.

Wait

Wait for a number of time steps without doing anything.

Selfdestruct

Self-destruct.

Move

Move forward one step.

Backup

Move backward one step.

Volume

Measure the size of the enclosed volume

Path

Describe a path to the destination.

Push

Push an entity forward one step.

Stride

Move forward multiple steps.

Turn

Turn in some direction.

Grab

Grab an item from the current location.

Harvest

Harvest an item from the current location.

Sow

Scatter seeds of a plant

Ignite

Ignite a combustible item

Place

Try to place an item at the current location.

Ping

Obtain the relative location of another robot.

Give

Give an item to another robot at the current location.

Equip

Equip a device on oneself.

Unequip

Unequip an equipped device, returning to inventory.

Make

Make an item.

Has

Sense whether we have a certain item.

Equipped

Sense whether we have a certain device equipped.

Count

Sense how many of a certain item we have.

Drill

Drill through an entity.

Use

Use an entity with another.

Build

Construct a new robot.

Salvage

Deconstruct an old robot.

Reprogram

Reprogram a robot that has executed it's command with a new command

Say

Emit a message.

Listen

Listen for a message from other robots.

Log

Emit a log message.

View

View a certain robot.

Appear

Set color and what characters are used for display.

Create

Create an entity out of thin air. Only available in creative mode.

Halt

Tell a robot to halt.

Time

Get current time

Scout

Whereami

Get the current x, y coordinates

Waypoint

Get the x, y coordinates of a named waypoint, by index

Structure

Get the x, y coordinates of southwest corner of a constructed structure, by index

Floorplan

Get the width and height of a structure template

HasTag

Answer whether a given entity has the given tag

TagMembers

Cycle through the entity names that are labeled with a given tag

Detect

Locate the closest instance of a given entity within the rectangle specified by opposite corners, relative to the current location.

Resonate

Count the number of a given entity within the rectangle specified by opposite corners, relative to the current location.

Density

Count the number entities within the rectangle specified by opposite corners, relative to the current location.

Sniff

Get the distance to the closest instance of the specified entity.

Chirp

Get the direction to the closest instance of the specified entity.

Watch

Register a location to interrupt a wait upon changes

Surveil

Register a (remote) location to interrupt a wait upon changes

Heading

Get the current heading.

Blocked

See if we can move forward or not.

Scan

Scan a nearby cell

Upload

Upload knowledge to another robot

Ishere

See if a specific entity is here.

Isempty

Check whether the current cell is empty

Self

Get a reference to oneself

Parent

Get the robot's parent

Base

Get a reference to the base

Meet

Meet a nearby robot

MeetAll

Meet all nearby robots

Whoami

Get the robot's display name

Setname

Set the robot's display name

Random

Get a uniformly random integer.

Run

Run a program loaded from a file.

If

If-expressions.

Inl

Left injection.

Inr

Right injection.

Case

Case analysis on a sum type.

Fst

First projection.

Snd

Second projection.

Force

Force a delayed evaluation.

Return

Return for the cmd monad.

Try

Try/catch block

Undefined

Undefined

Fail

User error

Not

Logical negation.

Neg

Arithmetic negation.

Eq

Logical equality comparison

Neq

Logical inequality comparison

Lt

Logical lesser-then comparison

Gt

Logical greater-then comparison

Leq

Logical lesser-or-equal comparison

Geq

Logical greater-or-equal comparison

Or

Logical or.

And

Logical and.

Add

Arithmetic addition operator

Sub

Arithmetic subtraction operator

Mul

Arithmetic multiplication operator

Div

Arithmetic division operator

Exp

Arithmetic exponentiation operator

Format

Turn an arbitrary value into a string

Concat

Concatenate string values

Chars

Count number of characters.

Split

Split string into two parts.

CharAt

Get the character at an index.

ToChar

Create a singleton text value with the given character code.

AppF

Application operator - helps to avoid parentheses: f $ g $ h x = f (g (h x))

Swap

Swap placed entity with one in inventory. Essentially atomic grab and place.

Atomic

When executing atomic c, a robot will not be interrupted, that is, no other robots will execute any commands while the robot is executing c.

Instant

Like atomic, but with no restriction on program size.

Key

Create key values.

InstallKeyHandler

Install a new keyboard input handler.

Teleport

Teleport a robot to the given position.

As

Run a command as if you were another robot.

RobotNamed

Find an actor by name.

RobotNumbered

Find an actor by number.

Knows

Check if an entity is known.

Instances

FromJSON Const

Defined in Swarm.Language.Syntax.Constants

Methods

parseJSON :: Value -> Parser Const

parseJSONList :: Value -> Parser [Const]

omittedField :: Maybe Const

FromJSONKey Const

Defined in Swarm.Language.Syntax.Constants

Methods

fromJSONKey :: FromJSONKeyFunction Const

fromJSONKeyList :: FromJSONKeyFunction [Const]

ToJSON Const

Defined in Swarm.Language.Syntax.Constants

Methods

toJSON :: Const -> Value

toEncoding :: Const -> Encoding

toJSONList :: [Const] -> Value

toEncodingList :: [Const] -> Encoding

omitField :: Const -> Bool

ToJSONKey Const

Defined in Swarm.Language.Syntax.Constants

Methods

toJSONKey :: ToJSONKeyFunction Const

toJSONKeyList :: ToJSONKeyFunction [Const]

Data Const

Defined in Swarm.Language.Syntax.Constants

Methods

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

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

toConstr :: Const -> Constr

dataTypeOf :: Const -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Const -> Const

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

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

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

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

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

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

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

Bounded Const

Defined in Swarm.Language.Syntax.Constants

Methods

minBound :: Const

maxBound :: Const

Enum Const

Defined in Swarm.Language.Syntax.Constants

Methods

succ :: Const -> Const

pred :: Const -> Const

toEnum :: Int -> Const

fromEnum :: Const -> Int

enumFrom :: Const -> [Const]

enumFromThen :: Const -> Const -> [Const]

enumFromTo :: Const -> Const -> [Const]

enumFromThenTo :: Const -> Const -> Const -> [Const]

Generic Const

Defined in Swarm.Language.Syntax.Constants

Associated Types

type Rep Const :: Type -> Type

Methods

from :: Const -> Rep Const x

to :: Rep Const x -> Const

Show Const

Defined in Swarm.Language.Syntax.Constants

Methods

showsPrec :: Int -> Const -> ShowS

show :: Const -> String

showList :: [Const] -> ShowS

Eq Const

Defined in Swarm.Language.Syntax.Constants

Methods

(==) :: Const -> Const -> Bool

(/=) :: Const -> Const -> Bool

Ord Const

Defined in Swarm.Language.Syntax.Constants

Methods

compare :: Const -> Const -> Ordering

(<) :: Const -> Const -> Bool

(<=) :: Const -> Const -> Bool

(>) :: Const -> Const -> Bool

(>=) :: Const -> Const -> Bool

max :: Const -> Const -> Const

min :: Const -> Const -> Const

PrettyPrec Const

Defined in Swarm.Language.Pretty

Methods

prettyPrec :: Int -> Const -> Doc ann

type Rep Const

Defined in Swarm.Language.Syntax.Constants

type Rep Const = D1 ('MetaData "Const" "Swarm.Language.Syntax.Constants" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) ((((((C1 ('MetaCons "Noop" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Wait" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Selfdestruct" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "Move" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Backup" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Volume" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "Path" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Push" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Stride" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Turn" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Grab" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Harvest" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Sow" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "Ignite" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Place" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Ping" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Give" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Equip" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Unequip" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Make" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "Has" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Equipped" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Count" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Drill" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Use" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Build" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Salvage" 'PrefixI 'False) (U1 :: Type -> Type)))))) :+: ((((C1 ('MetaCons "Reprogram" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Say" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Listen" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "Log" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "View" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Appear" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "Create" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Halt" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Time" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Scout" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Whereami" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Waypoint" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Structure" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "Floorplan" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "HasTag" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TagMembers" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Detect" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Resonate" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Density" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Sniff" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "Chirp" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Watch" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Surveil" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Heading" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Blocked" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Scan" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Upload" 'PrefixI 'False) (U1 :: Type -> Type))))))) :+: (((((C1 ('MetaCons "Ishere" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Isempty" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Self" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "Parent" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Base" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Meet" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "MeetAll" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Whoami" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Setname" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Random" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Run" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "If" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Inl" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "Inr" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Case" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Fst" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Snd" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Force" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Return" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Try" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "Undefined" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Fail" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Not" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Neg" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Eq" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Neq" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Lt" 'PrefixI 'False) (U1 :: Type -> Type)))))) :+: ((((C1 ('MetaCons "Gt" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Leq" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Geq" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "Or" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "And" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Add" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "Sub" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Mul" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Div" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Exp" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Format" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Concat" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Chars" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "Split" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "CharAt" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ToChar" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "AppF" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Swap" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Atomic" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Instant" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "Key" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "InstallKeyHandler" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Teleport" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "As" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RobotNamed" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "RobotNumbered" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Knows" 'PrefixI 'False) (U1 :: Type -> Type))))))))

allConst :: [Const]

data ConstInfo

Constructors

ConstInfo

Fields

• syntax :: Text
• fixity :: Int
• constMeta :: ConstMeta
• constDoc :: ConstDoc
• tangibility :: Tangibility

Instances

Show ConstInfo

Defined in Swarm.Language.Syntax.Constants

Methods

showsPrec :: Int -> ConstInfo -> ShowS

show :: ConstInfo -> String

showList :: [ConstInfo] -> ShowS

Eq ConstInfo

Defined in Swarm.Language.Syntax.Constants

Methods

(==) :: ConstInfo -> ConstInfo -> Bool

(/=) :: ConstInfo -> ConstInfo -> Bool

Ord ConstInfo

Defined in Swarm.Language.Syntax.Constants

Methods

compare :: ConstInfo -> ConstInfo -> Ordering

(<) :: ConstInfo -> ConstInfo -> Bool

(<=) :: ConstInfo -> ConstInfo -> Bool

(>) :: ConstInfo -> ConstInfo -> Bool

(>=) :: ConstInfo -> ConstInfo -> Bool

max :: ConstInfo -> ConstInfo -> ConstInfo

min :: ConstInfo -> ConstInfo -> ConstInfo

data ConstDoc

Constructors

ConstDoc

Fields

• effectInfo :: Set CommandEffect

  NOTE: The absence of effects implies a "pure computation".

• briefDoc :: Text
• longDoc :: Text

Instances

Show ConstDoc

Defined in Swarm.Language.Syntax.Constants

Methods

showsPrec :: Int -> ConstDoc -> ShowS

show :: ConstDoc -> String

showList :: [ConstDoc] -> ShowS

Eq ConstDoc

Defined in Swarm.Language.Syntax.Constants

Methods

(==) :: ConstDoc -> ConstDoc -> Bool

(/=) :: ConstDoc -> ConstDoc -> Bool

Ord ConstDoc

Defined in Swarm.Language.Syntax.Constants

Methods

compare :: ConstDoc -> ConstDoc -> Ordering

(<) :: ConstDoc -> ConstDoc -> Bool

(<=) :: ConstDoc -> ConstDoc -> Bool

(>) :: ConstDoc -> ConstDoc -> Bool

(>=) :: ConstDoc -> ConstDoc -> Bool

max :: ConstDoc -> ConstDoc -> ConstDoc

min :: ConstDoc -> ConstDoc -> ConstDoc

data ConstMeta

Constructors

ConstMFunc

Function with arity of which some are commands

Fields

• Int

  Arity

• Bool

  Is a command?

ConstMUnOp MUnAssoc

Unary operator with fixity and associativity.

ConstMBinOp MBinAssoc

Binary operator with fixity and associativity.

Instances

Show ConstMeta

Defined in Swarm.Language.Syntax.Constants

Methods

showsPrec :: Int -> ConstMeta -> ShowS

show :: ConstMeta -> String

showList :: [ConstMeta] -> ShowS

Eq ConstMeta

Defined in Swarm.Language.Syntax.Constants

Methods

(==) :: ConstMeta -> ConstMeta -> Bool

(/=) :: ConstMeta -> ConstMeta -> Bool

Ord ConstMeta

Defined in Swarm.Language.Syntax.Constants

Methods

compare :: ConstMeta -> ConstMeta -> Ordering

(<) :: ConstMeta -> ConstMeta -> Bool

(<=) :: ConstMeta -> ConstMeta -> Bool

(>) :: ConstMeta -> ConstMeta -> Bool

(>=) :: ConstMeta -> ConstMeta -> Bool

max :: ConstMeta -> ConstMeta -> ConstMeta

min :: ConstMeta -> ConstMeta -> ConstMeta

data MBinAssoc

The meta type representing associativity of binary operator.

Constructors

L

Left associative binary operator (see InfixL)

N

Non-associative binary operator (see InfixN)

R

Right associative binary operator (see InfixR)

Instances

Show MBinAssoc

Defined in Swarm.Language.Syntax.Constants

Methods

showsPrec :: Int -> MBinAssoc -> ShowS

show :: MBinAssoc -> String

showList :: [MBinAssoc] -> ShowS

Eq MBinAssoc

Defined in Swarm.Language.Syntax.Constants

Methods

(==) :: MBinAssoc -> MBinAssoc -> Bool

(/=) :: MBinAssoc -> MBinAssoc -> Bool

Ord MBinAssoc

Defined in Swarm.Language.Syntax.Constants

Methods

compare :: MBinAssoc -> MBinAssoc -> Ordering

(<) :: MBinAssoc -> MBinAssoc -> Bool

(<=) :: MBinAssoc -> MBinAssoc -> Bool

(>) :: MBinAssoc -> MBinAssoc -> Bool

(>=) :: MBinAssoc -> MBinAssoc -> Bool

max :: MBinAssoc -> MBinAssoc -> MBinAssoc

min :: MBinAssoc -> MBinAssoc -> MBinAssoc

data MUnAssoc

The meta type representing associativity of unary operator.

Constructors

P

Prefix unary operator (see Prefix)

S

Suffix unary operator (see Suffix)

Instances

Show MUnAssoc

Defined in Swarm.Language.Syntax.Constants

Methods

showsPrec :: Int -> MUnAssoc -> ShowS

show :: MUnAssoc -> String

showList :: [MUnAssoc] -> ShowS

Eq MUnAssoc

Defined in Swarm.Language.Syntax.Constants

Methods

(==) :: MUnAssoc -> MUnAssoc -> Bool

(/=) :: MUnAssoc -> MUnAssoc -> Bool

Ord MUnAssoc

Defined in Swarm.Language.Syntax.Constants

Methods

compare :: MUnAssoc -> MUnAssoc -> Ordering

(<) :: MUnAssoc -> MUnAssoc -> Bool

(<=) :: MUnAssoc -> MUnAssoc -> Bool

(>) :: MUnAssoc -> MUnAssoc -> Bool

(>=) :: MUnAssoc -> MUnAssoc -> Bool

max :: MUnAssoc -> MUnAssoc -> MUnAssoc

min :: MUnAssoc -> MUnAssoc -> MUnAssoc

constInfo :: Const -> ConstInfo

Information about constants used in parsing and pretty printing.

It would be more compact to represent the information by testing whether the constants are in certain sets, but using pattern matching gives us warning if we add more constants.

arity :: Const -> Int

The arity of a constant, i.e. how many arguments it expects. The runtime system will collect arguments to a constant (see VCApp) until it has enough, then dispatch the constant's behavior.

isCmd :: Const -> Bool

Whether a constant represents a command. Constants which are not commands are functions which are interpreted as soon as they are evaluated. Commands, on the other hand, are not interpreted until being executed, that is, when meeting an FExec frame. When evaluated, commands simply turn into a VCApp.

isUserFunc :: Const -> Bool

Function constants user can call with reserved words (wait,...).

isOperator :: Const -> Bool

Whether the constant is an operator. Useful predicate for documentation.

isBuiltinFunction :: Const -> Bool

Whether the constant is a function which is interpreted as soon as it is evaluated, but *not* including operators.

Note: This is used for documentation purposes and complements isCmd and isOperator in that exactly one will accept a given constant.

isTangible :: Const -> Bool

Whether the constant is a tangible command, that has an external effect on the world. At most one tangible command may be executed per tick.

isLong :: Const -> Bool

Whether the constant is a long command, that is, a tangible command which could require multiple ticks to execute. Such commands cannot be allowed in atomic blocks.

Size limits

maxSniffRange :: Int32

Maximum perception distance for Chirp and Sniff commands

maxScoutRange :: Int

maxStrideRange :: Int

maxPathRange :: Integer

globalMaxVolume :: Integer

Checked upon invocation of the command, before flood fill computation, to ensure the search has a reasonable bound.

The user is warned in the failure message that there exists a global limit.

SrcLoc

data SrcLoc

The location of something in the textual source code (recorded as an interval measured in terms of indices into the input stream).

Constructors

NoLoc

SrcLoc Int Int

Half-open interval from start (inclusive) to end (exclusive)

Instances

FromJSON SrcLoc

Defined in Swarm.Language.Syntax.Loc

Methods

parseJSON :: Value -> Parser SrcLoc

parseJSONList :: Value -> Parser [SrcLoc]

omittedField :: Maybe SrcLoc

ToJSON SrcLoc

Defined in Swarm.Language.Syntax.Loc

Methods

toJSON :: SrcLoc -> Value

toEncoding :: SrcLoc -> Encoding

toJSONList :: [SrcLoc] -> Value

toEncodingList :: [SrcLoc] -> Encoding

omitField :: SrcLoc -> Bool

Data SrcLoc

Defined in Swarm.Language.Syntax.Loc

Methods

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

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

toConstr :: SrcLoc -> Constr

dataTypeOf :: SrcLoc -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> SrcLoc -> SrcLoc

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

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

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

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

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

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

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

Monoid SrcLoc

mempty is a special value which means we have no location information.

Defined in Swarm.Language.Syntax.Loc

Methods

mempty :: SrcLoc

mappend :: SrcLoc -> SrcLoc -> SrcLoc

mconcat :: [SrcLoc] -> SrcLoc

Semigroup SrcLoc

x <> y is the smallest SrcLoc that subsumes both x and y.

Defined in Swarm.Language.Syntax.Loc

Methods

(<>) :: SrcLoc -> SrcLoc -> SrcLoc

sconcat :: NonEmpty SrcLoc -> SrcLoc

stimes :: Integral b => b -> SrcLoc -> SrcLoc

Generic SrcLoc

Defined in Swarm.Language.Syntax.Loc

Associated Types

type Rep SrcLoc :: Type -> Type

Methods

from :: SrcLoc -> Rep SrcLoc x

to :: Rep SrcLoc x -> SrcLoc

Show SrcLoc

Defined in Swarm.Language.Syntax.Loc

Methods

showsPrec :: Int -> SrcLoc -> ShowS

show :: SrcLoc -> String

showList :: [SrcLoc] -> ShowS

Eq SrcLoc

Defined in Swarm.Language.Syntax.Loc

Methods

(==) :: SrcLoc -> SrcLoc -> Bool

(/=) :: SrcLoc -> SrcLoc -> Bool

Ord SrcLoc

Defined in Swarm.Language.Syntax.Loc

Methods

compare :: SrcLoc -> SrcLoc -> Ordering

(<) :: SrcLoc -> SrcLoc -> Bool

(<=) :: SrcLoc -> SrcLoc -> Bool

(>) :: SrcLoc -> SrcLoc -> Bool

(>=) :: SrcLoc -> SrcLoc -> Bool

max :: SrcLoc -> SrcLoc -> SrcLoc

min :: SrcLoc -> SrcLoc -> SrcLoc

type Rep SrcLoc

Defined in Swarm.Language.Syntax.Loc

type Rep SrcLoc = D1 ('MetaData "SrcLoc" "Swarm.Language.Syntax.Loc" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) (C1 ('MetaCons "NoLoc" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SrcLoc" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int)))

srcLocBefore :: SrcLoc -> SrcLoc -> Bool

Check whether one SrcLoc starts at or before another one, i.e. compare their starting indices to see if the first is <= the second.

noLoc :: Term -> Syntax

Comments

data CommentType

Line vs block comments.

Constructors

LineComment

BlockComment

Instances

FromJSON CommentType

Defined in Swarm.Language.Syntax.Comments

Methods

parseJSON :: Value -> Parser CommentType

parseJSONList :: Value -> Parser [CommentType]

omittedField :: Maybe CommentType

ToJSON CommentType

Defined in Swarm.Language.Syntax.Comments

Methods

toJSON :: CommentType -> Value

toEncoding :: CommentType -> Encoding

toJSONList :: [CommentType] -> Value

toEncodingList :: [CommentType] -> Encoding

omitField :: CommentType -> Bool

Data CommentType

Defined in Swarm.Language.Syntax.Comments

Methods

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

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

toConstr :: CommentType -> Constr

dataTypeOf :: CommentType -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> CommentType -> CommentType

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

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

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

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

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

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

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

Bounded CommentType

Defined in Swarm.Language.Syntax.Comments

Methods

minBound :: CommentType

maxBound :: CommentType

Enum CommentType

Defined in Swarm.Language.Syntax.Comments

Methods

succ :: CommentType -> CommentType

pred :: CommentType -> CommentType

toEnum :: Int -> CommentType

fromEnum :: CommentType -> Int

enumFrom :: CommentType -> [CommentType]

enumFromThen :: CommentType -> CommentType -> [CommentType]

enumFromTo :: CommentType -> CommentType -> [CommentType]

enumFromThenTo :: CommentType -> CommentType -> CommentType -> [CommentType]

Generic CommentType

Defined in Swarm.Language.Syntax.Comments

Associated Types

type Rep CommentType :: Type -> Type

Methods

from :: CommentType -> Rep CommentType x

to :: Rep CommentType x -> CommentType

Read CommentType

Defined in Swarm.Language.Syntax.Comments

Methods

readsPrec :: Int -> ReadS CommentType

readList :: ReadS [CommentType]

readPrec :: ReadPrec CommentType

readListPrec :: ReadPrec [CommentType]

Show CommentType

Defined in Swarm.Language.Syntax.Comments

Methods

showsPrec :: Int -> CommentType -> ShowS

show :: CommentType -> String

showList :: [CommentType] -> ShowS

Eq CommentType

Defined in Swarm.Language.Syntax.Comments

Methods

(==) :: CommentType -> CommentType -> Bool

(/=) :: CommentType -> CommentType -> Bool

Ord CommentType

Defined in Swarm.Language.Syntax.Comments

Methods

compare :: CommentType -> CommentType -> Ordering

(<) :: CommentType -> CommentType -> Bool

(<=) :: CommentType -> CommentType -> Bool

(>) :: CommentType -> CommentType -> Bool

(>=) :: CommentType -> CommentType -> Bool

max :: CommentType -> CommentType -> CommentType

min :: CommentType -> CommentType -> CommentType

type Rep CommentType

Defined in Swarm.Language.Syntax.Comments

type Rep CommentType = D1 ('MetaData "CommentType" "Swarm.Language.Syntax.Comments" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) (C1 ('MetaCons "LineComment" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BlockComment" 'PrefixI 'False) (U1 :: Type -> Type))

data CommentSituation

Was a comment all by itself on a line, or did it occur after some other tokens on a line?

Constructors

StandaloneComment

SuffixComment

Instances

FromJSON CommentSituation

Defined in Swarm.Language.Syntax.Comments

Methods

parseJSON :: Value -> Parser CommentSituation

parseJSONList :: Value -> Parser [CommentSituation]

omittedField :: Maybe CommentSituation

ToJSON CommentSituation

Defined in Swarm.Language.Syntax.Comments

Methods

toJSON :: CommentSituation -> Value

toEncoding :: CommentSituation -> Encoding

toJSONList :: [CommentSituation] -> Value

toEncodingList :: [CommentSituation] -> Encoding

omitField :: CommentSituation -> Bool

Data CommentSituation

Defined in Swarm.Language.Syntax.Comments

Methods

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

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

toConstr :: CommentSituation -> Constr

dataTypeOf :: CommentSituation -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> CommentSituation -> CommentSituation

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

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

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

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

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

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

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

Bounded CommentSituation

Defined in Swarm.Language.Syntax.Comments

Methods

minBound :: CommentSituation

maxBound :: CommentSituation

Enum CommentSituation

Defined in Swarm.Language.Syntax.Comments

Methods

succ :: CommentSituation -> CommentSituation

pred :: CommentSituation -> CommentSituation

toEnum :: Int -> CommentSituation

fromEnum :: CommentSituation -> Int

enumFrom :: CommentSituation -> [CommentSituation]

enumFromThen :: CommentSituation -> CommentSituation -> [CommentSituation]

enumFromTo :: CommentSituation -> CommentSituation -> [CommentSituation]

enumFromThenTo :: CommentSituation -> CommentSituation -> CommentSituation -> [CommentSituation]

Generic CommentSituation

Defined in Swarm.Language.Syntax.Comments

Associated Types

type Rep CommentSituation :: Type -> Type

Methods

from :: CommentSituation -> Rep CommentSituation x

to :: Rep CommentSituation x -> CommentSituation

Read CommentSituation

Defined in Swarm.Language.Syntax.Comments

Methods

readsPrec :: Int -> ReadS CommentSituation

readList :: ReadS [CommentSituation]

readPrec :: ReadPrec CommentSituation

readListPrec :: ReadPrec [CommentSituation]

Show CommentSituation

Defined in Swarm.Language.Syntax.Comments

Methods

showsPrec :: Int -> CommentSituation -> ShowS

show :: CommentSituation -> String

showList :: [CommentSituation] -> ShowS

Eq CommentSituation

Defined in Swarm.Language.Syntax.Comments

Methods

(==) :: CommentSituation -> CommentSituation -> Bool

(/=) :: CommentSituation -> CommentSituation -> Bool

Ord CommentSituation

Defined in Swarm.Language.Syntax.Comments

Methods

compare :: CommentSituation -> CommentSituation -> Ordering

(<) :: CommentSituation -> CommentSituation -> Bool

(<=) :: CommentSituation -> CommentSituation -> Bool

(>) :: CommentSituation -> CommentSituation -> Bool

(>=) :: CommentSituation -> CommentSituation -> Bool

max :: CommentSituation -> CommentSituation -> CommentSituation

min :: CommentSituation -> CommentSituation -> CommentSituation

type Rep CommentSituation

Defined in Swarm.Language.Syntax.Comments

type Rep CommentSituation = D1 ('MetaData "CommentSituation" "Swarm.Language.Syntax.Comments" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) (C1 ('MetaCons "StandaloneComment" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SuffixComment" 'PrefixI 'False) (U1 :: Type -> Type))

isStandalone :: Comment -> Bool

Test whether a comment is a standalone comment or not.

data Comment

A comment is retained as some text plus metadata (source location, comment type, + comment situation). While parsing we record all comments out-of-band, for later re-insertion into the AST.

Constructors

Comment

Fields

• commentSrcLoc :: SrcLoc
• commentType :: CommentType
• commentSituation :: CommentSituation
• commentText :: Text

Instances

FromJSON Comment

Defined in Swarm.Language.Syntax.Comments

Methods

parseJSON :: Value -> Parser Comment

parseJSONList :: Value -> Parser [Comment]

omittedField :: Maybe Comment

ToJSON Comment

Defined in Swarm.Language.Syntax.Comments

Methods

toJSON :: Comment -> Value

toEncoding :: Comment -> Encoding

toJSONList :: [Comment] -> Value

toEncodingList :: [Comment] -> Encoding

omitField :: Comment -> Bool

Data Comment

Defined in Swarm.Language.Syntax.Comments

Methods

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

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

toConstr :: Comment -> Constr

dataTypeOf :: Comment -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Comment -> Comment

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

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

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

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

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

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

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

Generic Comment

Defined in Swarm.Language.Syntax.Comments

Associated Types

type Rep Comment :: Type -> Type

Methods

from :: Comment -> Rep Comment x

to :: Rep Comment x -> Comment

Show Comment

Defined in Swarm.Language.Syntax.Comments

Methods

showsPrec :: Int -> Comment -> ShowS

show :: Comment -> String

showList :: [Comment] -> ShowS

Eq Comment

Defined in Swarm.Language.Syntax.Comments

Methods

(==) :: Comment -> Comment -> Bool

(/=) :: Comment -> Comment -> Bool

PrettyPrec Comment

Defined in Swarm.Language.Pretty

Methods

prettyPrec :: Int -> Comment -> Doc ann

type Rep Comment

Defined in Swarm.Language.Syntax.Comments

type Rep Comment = D1 ('MetaData "Comment" "Swarm.Language.Syntax.Comments" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) (C1 ('MetaCons "Comment" 'PrefixI 'True) ((S1 ('MetaSel ('Just "commentSrcLoc") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SrcLoc) :*: S1 ('MetaSel ('Just "commentType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 CommentType)) :*: (S1 ('MetaSel ('Just "commentSituation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 CommentSituation) :*: S1 ('MetaSel ('Just "commentText") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text))))

data Comments

Comments which can be attached to a particular AST node. Some comments come textually before the node and some come after.

Constructors

Comments

Fields

• _beforeComments :: Seq Comment
• _afterComments :: Seq Comment

Instances

FromJSON Comments

Defined in Swarm.Language.Syntax.Comments

Methods

parseJSON :: Value -> Parser Comments

parseJSONList :: Value -> Parser [Comments]

omittedField :: Maybe Comments

ToJSON Comments

Defined in Swarm.Language.Syntax.Comments

Methods

toJSON :: Comments -> Value

toEncoding :: Comments -> Encoding

toJSONList :: [Comments] -> Value

toEncodingList :: [Comments] -> Encoding

omitField :: Comments -> Bool

Data Comments

Defined in Swarm.Language.Syntax.Comments

Methods

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

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

toConstr :: Comments -> Constr

dataTypeOf :: Comments -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Comments -> Comments

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

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

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

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

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

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

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

Monoid Comments

Defined in Swarm.Language.Syntax.Comments

Methods

mempty :: Comments

mappend :: Comments -> Comments -> Comments

mconcat :: [Comments] -> Comments

Semigroup Comments

Defined in Swarm.Language.Syntax.Comments

Methods

(<>) :: Comments -> Comments -> Comments

sconcat :: NonEmpty Comments -> Comments

stimes :: Integral b => b -> Comments -> Comments

Generic Comments

Defined in Swarm.Language.Syntax.Comments

Associated Types

type Rep Comments :: Type -> Type

Methods

from :: Comments -> Rep Comments x

to :: Rep Comments x -> Comments

Show Comments

Defined in Swarm.Language.Syntax.Comments

Methods

showsPrec :: Int -> Comments -> ShowS

show :: Comments -> String

showList :: [Comments] -> ShowS

Eq Comments

Defined in Swarm.Language.Syntax.Comments

Methods

(==) :: Comments -> Comments -> Bool

(/=) :: Comments -> Comments -> Bool

AsEmpty Comments

Defined in Swarm.Language.Syntax.Comments

Methods

_Empty :: Prism' Comments ()

type Rep Comments

Defined in Swarm.Language.Syntax.Comments

type Rep Comments = D1 ('MetaData "Comments" "Swarm.Language.Syntax.Comments" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) (C1 ('MetaCons "Comments" 'PrefixI 'True) (S1 ('MetaSel ('Just "_beforeComments") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Seq Comment)) :*: S1 ('MetaSel ('Just "_afterComments") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Seq Comment))))

beforeComments :: Lens' Comments (Seq Comment)

afterComments :: Lens' Comments (Seq Comment)

Syntax

data Syntax' ty

The surface syntax for the language, with location and type annotations.

Constructors

Syntax'

Fields

• _sLoc :: SrcLoc
• _sTerm :: Term' ty
• _sComments :: Comments
• _sType :: ty

Instances

FromJSON Syntax

Defined in Swarm.Language.JSON

Methods

parseJSON :: Value -> Parser Syntax

parseJSONList :: Value -> Parser [Syntax]

omittedField :: Maybe Syntax

FromJSON TSyntax

Defined in Swarm.Language.JSON

Methods

parseJSON :: Value -> Parser TSyntax

parseJSONList :: Value -> Parser [TSyntax]

omittedField :: Maybe TSyntax

ToJSON Syntax

Defined in Swarm.Language.JSON

Methods

toJSON :: Syntax -> Value

toEncoding :: Syntax -> Encoding

toJSONList :: [Syntax] -> Value

toEncodingList :: [Syntax] -> Encoding

omitField :: Syntax -> Bool

ToJSON TSyntax

Defined in Swarm.Language.JSON

Methods

toJSON :: TSyntax -> Value

toEncoding :: TSyntax -> Encoding

toJSONList :: [TSyntax] -> Value

toEncodingList :: [TSyntax] -> Encoding

omitField :: TSyntax -> Bool

Foldable Syntax'

Defined in Swarm.Language.Syntax.AST

Methods

fold :: Monoid m => Syntax' m -> m

foldMap :: Monoid m => (a -> m) -> Syntax' a -> m

foldMap' :: Monoid m => (a -> m) -> Syntax' a -> m

foldr :: (a -> b -> b) -> b -> Syntax' a -> b

foldr' :: (a -> b -> b) -> b -> Syntax' a -> b

foldl :: (b -> a -> b) -> b -> Syntax' a -> b

foldl' :: (b -> a -> b) -> b -> Syntax' a -> b

foldr1 :: (a -> a -> a) -> Syntax' a -> a

foldl1 :: (a -> a -> a) -> Syntax' a -> a

toList :: Syntax' a -> [a]

null :: Syntax' a -> Bool

length :: Syntax' a -> Int

elem :: Eq a => a -> Syntax' a -> Bool

maximum :: Ord a => Syntax' a -> a

minimum :: Ord a => Syntax' a -> a

sum :: Num a => Syntax' a -> a

product :: Num a => Syntax' a -> a

Traversable Syntax'

Defined in Swarm.Language.Syntax.AST

Methods

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

sequenceA :: Applicative f => Syntax' (f a) -> f (Syntax' a)

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

sequence :: Monad m => Syntax' (m a) -> m (Syntax' a)

Functor Syntax'

Defined in Swarm.Language.Syntax.AST

Methods

fmap :: (a -> b) -> Syntax' a -> Syntax' b

(<$) :: a -> Syntax' b -> Syntax' a

FromJSON (Document Syntax)

Defined in Swarm.Language.Text.Markdown

Methods

parseJSON :: Value -> Parser (Document Syntax)

parseJSONList :: Value -> Parser [Document Syntax]

omittedField :: Maybe (Document Syntax)

ToJSON (Document Syntax)

Defined in Swarm.Language.Text.Markdown

Methods

toJSON :: Document Syntax -> Value

toEncoding :: Document Syntax -> Encoding

toJSONList :: [Document Syntax] -> Value

toEncodingList :: [Document Syntax] -> Encoding

omitField :: Document Syntax -> Bool

ToJSON (Paragraph Syntax)

Defined in Swarm.Language.Text.Markdown

Methods

toJSON :: Paragraph Syntax -> Value

toEncoding :: Paragraph Syntax -> Encoding

toJSONList :: [Paragraph Syntax] -> Value

toEncodingList :: [Paragraph Syntax] -> Encoding

omitField :: Paragraph Syntax -> Bool

Data ty => Data (Syntax' ty)

Defined in Swarm.Language.Syntax.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Syntax' ty -> c (Syntax' ty)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Syntax' ty)

toConstr :: Syntax' ty -> Constr

dataTypeOf :: Syntax' ty -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Syntax' ty))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Syntax' ty))

gmapT :: (forall b. Data b => b -> b) -> Syntax' ty -> Syntax' ty

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Syntax' ty -> r

gmapQ :: (forall d. Data d => d -> u) -> Syntax' ty -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Syntax' ty -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Syntax' ty -> m (Syntax' ty)

IsString (Document Syntax)

Defined in Swarm.Language.Text.Markdown

Methods

fromString :: String -> Document Syntax

IsString (Paragraph Syntax)

Defined in Swarm.Language.Text.Markdown

Methods

fromString :: String -> Paragraph Syntax

Generic (Syntax' ty)

Defined in Swarm.Language.Syntax.AST

Associated Types

type Rep (Syntax' ty) :: Type -> Type

Methods

from :: Syntax' ty -> Rep (Syntax' ty) x

to :: Rep (Syntax' ty) x -> Syntax' ty

Show ty => Show (Syntax' ty)

Defined in Swarm.Language.Syntax.AST

Methods

showsPrec :: Int -> Syntax' ty -> ShowS

show :: Syntax' ty -> String

showList :: [Syntax' ty] -> ShowS

Eq ty => Eq (Syntax' ty)

Defined in Swarm.Language.Syntax.AST

Methods

(==) :: Syntax' ty -> Syntax' ty -> Bool

(/=) :: Syntax' ty -> Syntax' ty -> Bool

Data ty => Plated (Syntax' ty)

Defined in Swarm.Language.Syntax.AST

Methods

plate :: Traversal' (Syntax' ty) (Syntax' ty)

PrettyPrec (Syntax' ty)

Pretty-print a syntax node with comments.

Defined in Swarm.Language.Pretty

Methods

prettyPrec :: Int -> Syntax' ty -> Doc ann

type Rep (Syntax' ty)

Defined in Swarm.Language.Syntax.AST

type Rep (Syntax' ty) = D1 ('MetaData "Syntax'" "Swarm.Language.Syntax.AST" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) (C1 ('MetaCons "Syntax'" 'PrefixI 'True) ((S1 ('MetaSel ('Just "_sLoc") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SrcLoc) :*: S1 ('MetaSel ('Just "_sTerm") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Term' ty))) :*: (S1 ('MetaSel ('Just "_sComments") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Comments) :*: S1 ('MetaSel ('Just "_sType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ty))))

sLoc :: forall ty. Lens' (Syntax' ty) SrcLoc

sTerm :: forall ty. Lens' (Syntax' ty) (Term' ty)

sType :: forall ty. Lens' (Syntax' ty) ty

sComments :: forall ty. Lens' (Syntax' ty) Comments

type Syntax = Syntax' ()

Syntax without type annotations.

type TSyntax = Syntax' Polytype

type USyntax = Syntax' UType

pattern Syntax :: SrcLoc -> Term -> Syntax

Raw parsed syntax, without comments or type annotations.

pattern CSyntax :: SrcLoc -> Term -> Comments -> Syntax

Untyped syntax with assocated comments.

data LocVar

A variable with associated source location, used for variable binding sites. (Variable occurrences are a bare TVar which gets wrapped in a Syntax node, so we don't need LocVar for those.)

Constructors

LV

Fields

• lvSrcLoc :: SrcLoc
• lvVar :: Var

Instances

FromJSON LocVar

Defined in Swarm.Language.Syntax.Loc

Methods

parseJSON :: Value -> Parser LocVar

parseJSONList :: Value -> Parser [LocVar]

omittedField :: Maybe LocVar

ToJSON LocVar

Defined in Swarm.Language.Syntax.Loc

Methods

toJSON :: LocVar -> Value

toEncoding :: LocVar -> Encoding

toJSONList :: [LocVar] -> Value

toEncodingList :: [LocVar] -> Encoding

omitField :: LocVar -> Bool

Data LocVar

Defined in Swarm.Language.Syntax.Loc

Methods

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

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

toConstr :: LocVar -> Constr

dataTypeOf :: LocVar -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> LocVar -> LocVar

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

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

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

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

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

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

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

Generic LocVar

Defined in Swarm.Language.Syntax.Loc

Associated Types

type Rep LocVar :: Type -> Type

Methods

from :: LocVar -> Rep LocVar x

to :: Rep LocVar x -> LocVar

Show LocVar

Defined in Swarm.Language.Syntax.Loc

Methods

showsPrec :: Int -> LocVar -> ShowS

show :: LocVar -> String

showList :: [LocVar] -> ShowS

Eq LocVar

Defined in Swarm.Language.Syntax.Loc

Methods

(==) :: LocVar -> LocVar -> Bool

(/=) :: LocVar -> LocVar -> Bool

Ord LocVar

Defined in Swarm.Language.Syntax.Loc

Methods

compare :: LocVar -> LocVar -> Ordering

(<) :: LocVar -> LocVar -> Bool

(<=) :: LocVar -> LocVar -> Bool

(>) :: LocVar -> LocVar -> Bool

(>=) :: LocVar -> LocVar -> Bool

max :: LocVar -> LocVar -> LocVar

min :: LocVar -> LocVar -> LocVar

type Rep LocVar

Defined in Swarm.Language.Syntax.Loc

type Rep LocVar = D1 ('MetaData "LocVar" "Swarm.Language.Syntax.Loc" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) (C1 ('MetaCons "LV" 'PrefixI 'True) (S1 ('MetaSel ('Just "lvSrcLoc") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 SrcLoc) :*: S1 ('MetaSel ('Just "lvVar") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Var)))

data LetSyntax

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 appropriatly.

Constructors

LSLet

LSDef

Instances

FromJSON LetSyntax

Defined in Swarm.Language.Syntax.AST

Methods

parseJSON :: Value -> Parser LetSyntax

parseJSONList :: Value -> Parser [LetSyntax]

omittedField :: Maybe LetSyntax

ToJSON LetSyntax

Defined in Swarm.Language.Syntax.AST

Methods

toJSON :: LetSyntax -> Value

toEncoding :: LetSyntax -> Encoding

toJSONList :: [LetSyntax] -> Value

toEncodingList :: [LetSyntax] -> Encoding

omitField :: LetSyntax -> Bool

Data LetSyntax

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

Defined in Swarm.Language.Syntax.AST

Methods

minBound :: LetSyntax

maxBound :: LetSyntax

Enum LetSyntax

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

Defined in Swarm.Language.Syntax.AST

Associated Types

type Rep LetSyntax :: Type -> Type

Methods

from :: LetSyntax -> Rep LetSyntax x

to :: Rep LetSyntax x -> LetSyntax

Show LetSyntax

Defined in Swarm.Language.Syntax.AST

Methods

showsPrec :: Int -> LetSyntax -> ShowS

show :: LetSyntax -> String

showList :: [LetSyntax] -> ShowS

Eq LetSyntax

Defined in Swarm.Language.Syntax.AST

Methods

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

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

Ord LetSyntax

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

type Rep LetSyntax

Defined in Swarm.Language.Syntax.AST

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

pattern STerm :: Term -> Syntax

Match an untyped term without annotations.

pattern TRequirements :: Text -> Term -> Term

pattern TPair :: Term -> Term -> Term

Match a TPair without annotations.

pattern TLam :: Var -> Maybe Type -> Term -> Term

Match a TLam without annotations.

pattern TApp :: Term -> Term -> Term

Match a TApp without annotations.

pattern (:$:) :: Term -> Syntax -> Term infixl 0

Convenient infix pattern synonym for application.

pattern TLet :: LetSyntax -> Bool -> Var -> Maybe Polytype -> Maybe Requirements -> Term -> Term -> Term

Match a TLet without annotations.

pattern TTydef :: Var -> Polytype -> Maybe TydefInfo -> Term -> Term

Match a STydef without annotations.

pattern TBind :: Maybe Var -> Maybe Polytype -> Maybe Requirements -> Term -> Term -> Term

Match a TBind without annotations.

pattern TDelay :: Term -> Term

Match a TDelay without annotations.

pattern TRcd :: Map Var (Maybe Term) -> Term

Match a TRcd without annotations.

pattern TProj :: Term -> Var -> Term

pattern TAnnotate :: Term -> Polytype -> Term

Match a TAnnotate without annotations.

pattern TSuspend :: Term -> Term

Match a TSuspend without annotations.

Terms

type Var = Text

We use Text values to represent variables.

data DelayType

Different runtime behaviors for delayed expressions.

Constructors

SimpleDelay

A simple delay, implemented via a (non-memoized) VDelay holding the delayed expression.

MemoizedDelay (Maybe Var)

A memoized delay, implemented by allocating a mutable cell with the delayed expression and returning a reference to it. When the Maybe Var is Just, a recursive binding of the variable with a reference to the delayed expression will be provided while evaluating the delayed expression itself. Note that there is no surface syntax for binding a variable within a recursive delayed expression; the only way we can get Just here is when we automatically generate a delayed expression while interpreting a recursive let or def.

Instances

FromJSON DelayType

Defined in Swarm.Language.Syntax.AST

Methods

parseJSON :: Value -> Parser DelayType

parseJSONList :: Value -> Parser [DelayType]

omittedField :: Maybe DelayType

ToJSON DelayType

Defined in Swarm.Language.Syntax.AST

Methods

toJSON :: DelayType -> Value

toEncoding :: DelayType -> Encoding

toJSONList :: [DelayType] -> Value

toEncodingList :: [DelayType] -> Encoding

omitField :: DelayType -> Bool

Data DelayType

Defined in Swarm.Language.Syntax.AST

Methods

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

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

toConstr :: DelayType -> Constr

dataTypeOf :: DelayType -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> DelayType -> DelayType

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

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

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

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

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

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

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

Generic DelayType

Defined in Swarm.Language.Syntax.AST

Associated Types

type Rep DelayType :: Type -> Type

Methods

from :: DelayType -> Rep DelayType x

to :: Rep DelayType x -> DelayType

Show DelayType

Defined in Swarm.Language.Syntax.AST

Methods

showsPrec :: Int -> DelayType -> ShowS

show :: DelayType -> String

showList :: [DelayType] -> ShowS

Eq DelayType

Defined in Swarm.Language.Syntax.AST

Methods

(==) :: DelayType -> DelayType -> Bool

(/=) :: DelayType -> DelayType -> Bool

type Rep DelayType

Defined in Swarm.Language.Syntax.AST

type Rep DelayType = D1 ('MetaData "DelayType" "Swarm.Language.Syntax.AST" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) (C1 ('MetaCons "SimpleDelay" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MemoizedDelay" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Var))))

data Term' ty

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.

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.

TRequireDevice Text

Require a specific device to be installed.

TRequire 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 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 Requirements field is only for annotating the requirements of a definition after typechecking; there is no way to annotate requirements in the surface syntax.

STydef LocVar 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) Polytype

Annotate a term with a type

SSuspend (Syntax' ty)

Run the given command, then suspend and wait for a new REPL input.

Instances

FromJSON Term

Defined in Swarm.Language.JSON

Methods

parseJSON :: Value -> Parser Term

parseJSONList :: Value -> Parser [Term]

omittedField :: Maybe Term

ToJSON Term

Defined in Swarm.Language.JSON

Methods

toJSON :: Term -> Value

toEncoding :: Term -> Encoding

toJSONList :: [Term] -> Value

toEncodingList :: [Term] -> Encoding

omitField :: Term -> Bool

Foldable Term'

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'

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.

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'

Defined in Swarm.Language.Syntax.AST

Methods

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

(<$) :: a -> Term' b -> Term' a

Data ty => Data (Term' ty)

Defined in Swarm.Language.Syntax.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Term' ty -> c (Term' ty)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Term' ty)

toConstr :: Term' ty -> Constr

dataTypeOf :: Term' ty -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Term' ty))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Term' ty))

gmapT :: (forall b. Data b => b -> b) -> Term' ty -> Term' ty

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Term' ty -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Term' ty -> r

gmapQ :: (forall d. Data d => d -> u) -> Term' ty -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Term' ty -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Term' ty -> m (Term' ty)

Generic (Term' ty)

Defined in Swarm.Language.Syntax.AST

Associated Types

type Rep (Term' ty) :: Type -> Type

Methods

from :: Term' ty -> Rep (Term' ty) x

to :: Rep (Term' ty) x -> Term' ty

Show ty => Show (Term' ty)

Defined in Swarm.Language.Syntax.AST

Methods

showsPrec :: Int -> Term' ty -> ShowS

show :: Term' ty -> String

showList :: [Term' ty] -> ShowS

Eq ty => Eq (Term' ty)

Defined in Swarm.Language.Syntax.AST

Methods

(==) :: Term' ty -> Term' ty -> Bool

(/=) :: Term' ty -> Term' ty -> Bool

Data ty => Plated (Term' ty)

Defined in Swarm.Language.Syntax.AST

Methods

plate :: Traversal' (Term' ty) (Term' ty)

PrettyPrec (Term' ty)

Defined in Swarm.Language.Pretty

Methods

prettyPrec :: Int -> Term' ty -> Doc ann

type Rep (Term' ty)

Defined in Swarm.Language.Syntax.AST

type Rep (Term' ty) = D1 ('MetaData "Term'" "Swarm.Language.Syntax.AST" "swarm-0.6.0.0-ERx1HMcRMba59aI2b6aNrS-swarm-lang" 'False) ((((C1 ('MetaCons "TUnit" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TConst" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Const)) :+: C1 ('MetaCons "TDir" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Direction)))) :+: (C1 ('MetaCons "TInt" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Integer)) :+: (C1 ('MetaCons "TAntiInt" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: C1 ('MetaCons "TText" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text))))) :+: ((C1 ('MetaCons "TAntiText" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: (C1 ('MetaCons "TBool" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Bool)) :+: C1 ('MetaCons "TRobot" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int)))) :+: (C1 ('MetaCons "TRef" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int)) :+: (C1 ('MetaCons "TRequireDevice" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)) :+: C1 ('MetaCons "TRequire" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Int) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text)))))) :+: (((C1 ('MetaCons "SRequirements" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Text) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty))) :+: (C1 ('MetaCons "TVar" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Var)) :+: C1 ('MetaCons "SPair" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty))))) :+: (C1 ('MetaCons "SLam" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 LocVar) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Type)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty)))) :+: (C1 ('MetaCons "SApp" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty))) :+: C1 ('MetaCons "SLet" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 LetSyntax) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Bool) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 LocVar))) :*: ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Polytype)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Requirements))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty)))))))) :+: ((C1 ('MetaCons "STydef" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 LocVar) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Polytype)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe TydefInfo)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty)))) :+: (C1 ('MetaCons "SBind" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe LocVar)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe ty)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Polytype)))) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Requirements)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty))))) :+: C1 ('MetaCons "SDelay" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty))))) :+: ((C1 ('MetaCons "SRcd" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Map Var (Maybe (Syntax' ty))))) :+: C1 ('MetaCons "SProj" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Var))) :+: (C1 ('MetaCons "SAnnotate" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Polytype)) :+: C1 ('MetaCons "SSuspend" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Syntax' ty))))))))

type Term = Term' ()

type TTerm = Term' Polytype

type UTerm = Term' UType

mkOp :: Const -> Syntax -> Syntax -> Syntax

Make an infix operation (e.g. 2 + 3) a curried function application (e.g. ((+) 2) 3).

mkOp' :: Const -> Term -> Term -> Term

Make an infix operation, discarding any location information

unfoldApps :: Syntax' ty -> NonEmpty (Syntax' ty)

Turn function application chain into a list.

>>> syntaxWrap f = fmap (^. sTerm) . f . Syntax NoLoc
>>> syntaxWrap unfoldApps (mkOp' Mul (TInt 1) (TInt 2)) -- 1 * 2
TConst Mul :| [TInt 1,TInt 2]

mkTuple :: [Syntax] -> Syntax

Create a nested tuple out of a list of syntax nodes.

unTuple :: Syntax' ty -> [Syntax' ty]

Decompose a nested tuple into a list of components.

Erasure

erase :: Functor t => t ty -> t ()

Erase the type annotations from a Syntax or Term tree.

eraseS :: Syntax' ty -> Term

Erase all annotations from a Syntax node, turning it into a bare Term.

Term traversal

freeVarsS :: forall ty. Traversal' (Syntax' ty) (Syntax' ty)

Traversal over those subterms of a term which represent free variables. The S suffix indicates that it is a Traversal over the Syntax nodes (which contain type and source location info) containing free variables inside a larger Syntax value. Note that if you want to get the list of all Syntax nodes representing free variables, you can do so via toListOf freeVarsS.

freeVarsT :: forall ty. Traversal' (Syntax' ty) (Term' ty)

Like freeVarsS, but traverse over the Terms containing free variables. More direct if you don't need to know the types or source locations of the variables. Note that if you want to get the list of all Terms representing free variables, you can do so via toListOf freeVarsT.

freeVarsV :: Traversal' (Syntax' ty) Var

Traversal over the free variables of a term. Like freeVarsS and freeVarsT, but traverse over the variable names themselves. Note that if you want to get the set of all free variable names, you can do so via setOf freeVarsV.

mapFreeS :: Var -> (Syntax' ty -> Syntax' ty) -> Syntax' ty -> Syntax' ty

Apply a function to all free occurrences of a particular variable.

locVarToSyntax' :: LocVar -> ty -> Syntax' ty

asTree :: Data a => Syntax' a -> Tree (Syntax' a)

Transform the AST into a Tree datatype. Useful for pretty-printing (e.g. via "Data.Tree.drawTree").

measureAstSize :: Data a => Syntax' a -> Int

Each constructor is a assigned a value of 1, plus any recursive syntax it entails.