Swarm.Language.Pipeline

Some convenient functions for putting together the whole Swarm language processing pipeline: parsing, type checking, capability checking, and elaboration. If you want to simply turn some raw text representing a Swarm program into something useful, this is probably the module you want.

Documentation

data ProcessedTerm

A record containing the results of the language processing pipeline. Put a Term in, and get one of these out.

Constructors

ProcessedTerm

Fields

• Term

  The elaborated term

• TModule

  The type of the term (and of any embedded definitions)

• Requirements

  Requirements of the term

• ReqCtx

  Capability context for any definitions embedded in the term

Instances

FromJSON ProcessedTerm

Defined in Swarm.Language.Pipeline

Methods

parseJSON :: Value -> Parser ProcessedTerm

parseJSONList :: Value -> Parser [ProcessedTerm]

ToJSON ProcessedTerm

Defined in Swarm.Language.Pipeline

Methods

toJSON :: ProcessedTerm -> Value

toEncoding :: ProcessedTerm -> Encoding

toJSONList :: [ProcessedTerm] -> Value

toEncodingList :: [ProcessedTerm] -> Encoding

Data ProcessedTerm

Defined in Swarm.Language.Pipeline

Methods

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

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

toConstr :: ProcessedTerm -> Constr

dataTypeOf :: ProcessedTerm -> DataType

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

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

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

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

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

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

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

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

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

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

Generic ProcessedTerm

Defined in Swarm.Language.Pipeline

Associated Types

type Rep ProcessedTerm :: Type -> Type

Methods

from :: ProcessedTerm -> Rep ProcessedTerm x

to :: Rep ProcessedTerm x -> ProcessedTerm

Show ProcessedTerm

Defined in Swarm.Language.Pipeline

Methods

showsPrec :: Int -> ProcessedTerm -> ShowS

show :: ProcessedTerm -> String

showList :: [ProcessedTerm] -> ShowS

Eq ProcessedTerm

Defined in Swarm.Language.Pipeline

Methods

(==) :: ProcessedTerm -> ProcessedTerm -> Bool

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

type Rep ProcessedTerm

Defined in Swarm.Language.Pipeline

type Rep ProcessedTerm = D1 ('MetaData "ProcessedTerm" "Swarm.Language.Pipeline" "swarm-0.2.0.0-D1mAmWsUEjoFqpCaq9DHG0" 'False) (C1 ('MetaCons "ProcessedTerm" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Term) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 TModule)) :*: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Requirements) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 ReqCtx))))

processTerm :: Text -> Either Text (Maybe ProcessedTerm)

Given a Text value representing a Swarm program,

1. Parse it (see Swarm.Language.Parse)
2. Typecheck it (see Swarm.Language.Typecheck)
3. Elaborate it (see Swarm.Language.Elaborate)
4. Check what capabilities it requires (see Swarm.Language.Capability)

Return either the end result (or Nothing if the input was only whitespace) or a pretty-printed error message.

processParsedTerm :: Syntax -> Either TypeErr ProcessedTerm

Like processTerm, but use a term that has already been parsed.

processTerm' :: TCtx -> ReqCtx -> Text -> Either Text (Maybe ProcessedTerm)

Like processTerm, but use explicit starting contexts.

processParsedTerm' :: TCtx -> ReqCtx -> Syntax -> Either TypeErr ProcessedTerm

Like processTerm', but use a term that has already been parsed.

showTypeErrorPos :: Text -> TypeErr -> ((Int, Int), (Int, Int), Text)