Language.Sh.Syntax

Here we define the complete abstract syntax tree for simple and compound statements.

The statement level and above

data Command

Constructors

Synchronous AndOrList

Asynchronous AndOrList

Instances

Show Command

Pretty Command

(Monad m, Functor m) => ExpressionMapperM m (Command -> m Command)

Pretty [Command]

ExpressionMapper (Command -> Command)

data AndOrList

Constructors

Singleton Pipeline

AndOrList :&&: Pipeline

AndOrList :||: Pipeline

Instances

Show AndOrList

Pretty AndOrList

(Monad m, Functor m) => ExpressionMapperM m (AndOrList -> m AndOrList)

ExpressionMapper (AndOrList -> AndOrList)

data Pipeline

Constructors

Pipeline [Statement]

BangPipeline [Statement]

Instances

Show Pipeline

Pretty Pipeline

(Monad m, Functor m) => ExpressionMapperM m (Pipeline -> m Pipeline)

ExpressionMapper (Pipeline -> Pipeline)

data Term

Constructors

TWord Word

TRedir Redir

TAssignment Assignment

Instances

Show Term

Pretty Term

data Statement

Constructors

Statement [Word] [Redir] [Assignment]

Compound CompoundStatement [Redir]

FunctionDefinition String CompoundStatement [Redir]

OrderedStatement [Term]

Instances

Show Statement

Pretty Statement

(Monad m, Functor m) => ExpressionMapperM m (Statement -> m Statement)

ExpressionMapper (Statement -> Statement)

data CompoundStatement

Constructors

For String [Word] [Command]

While [Command] [Command]

Until [Command] [Command]

If [Command] [Command] [Command]

Case Word [([Word], [Command])]

Subshell [Command]

BraceGroup [Command]

Instances

Show CompoundStatement

Pretty CompoundStatement

(Monad m, Functor m) => ExpressionMapperM m (CompoundStatement -> m CompoundStatement)

ExpressionMapper (CompoundStatement -> CompoundStatement)

The word level and below

type Word = [Lexeme]

data Lexeme

Constructors

Literal Char

Quote Char

Expand Expansion

Quoted Lexeme

SplitField

Instances

Show Lexeme

Pretty Lexeme

(Monad m, Functor m) => ExpressionMapperM m (Lexeme -> m [Lexeme])

(Monad m, Functor m) => ExpressionMapperM m (Lexeme -> m Lexeme)

Pretty [Lexeme]

ExpressionMapper (Lexeme -> [Lexeme])

ExpressionMapper (Lexeme -> Lexeme)

data Expansion

An expansion. The first three are all variable expansions. The ModifiedExpansion in particular also keeps track of which operation it is to perform. The Char can be any of -+=? and the Bool says whether it was paired with a : in the case of the first four or doubled in the case of the latter two. This isn't a very good data structure, but I hesitate to add 12 more algebraic types, one for each type of expansion. It would be elegant to use a function parameter here, but then we lose our data-ness and it makes it difficult to be Show. We could use a data class that has functions and is also Show and can be pretty-printed, and this would allow arbitrary generalizability, but do we really want this? It needs to be parsed anyway. The other question is the bash extensions: do we parse for / or should it be an error? Is there a way to prevent it optionally?

Constructors

SimpleExpansion String

ModifiedExpansion String Char Bool Word

LengthExpansion String

CommandSub [Command]

Arithmetic Word

Instances

Show Expansion

Pretty Expansion

(Monad m, Functor m) => ExpressionMapperM m (Expansion -> m Expansion)

ExpressionMapper (Expansion -> Expansion)

data Redir

Constructors

Int :> Word

Int :>| Word

Int :>& Int

Int :>> Word

Int :<> Word

Int :< Word

Int :<& Int

Int :<< String

Int :<<- String

Heredoc Int Bool Word

filled in version...?

Instances

Show Redir

Pretty Redir

(Monad m, Functor m) => ExpressionMapperM m (Redir -> m Redir)

ExpressionMapper (Redir -> Redir)

data Assignment

Constructors

String := Word

Instances

Show Assignment

Pretty Assignment

(Monad m, Functor m) => ExpressionMapperM m (Assignment -> m Assignment)

ExpressionMapper (Assignment -> Assignment)