Portability	unportable
Stability	unstable
Maintainer	Martin Avanzini <martin.avanzini@uibk.ac.at>
Safe Haskell	None

Tct.Processor.Args.Instances

Contents

Constructors for Arguments

Description

This module defines various instances of processor arguments.

Synopsis

Documentation

data Proc a

Constructors

Proc a

Instances

ParsableArgument Processor
Processor a => Argument (Proc a)

type Processor = Proc AnyProcessor

newtype Assoc a

Constructors

Assoc a

Instances

(Show a, AssocArgument a) => ParsableArgument (Assoc a)
(Show a, AssocArgument a) => Argument (Assoc a)

class AssocArgument a where

Instances of this class can be parsed by means of the defined method assoc.

Methods

assoc :: Phantom a -> [(String, a)]

The resulting list associates names to elements, and should be finite. An element is parsed by parsing its name.

Instances

AssocArgument PolyShape
AssocArgument (RuleSelector SelectorExpression)

newtype EnumOf a

Constructors

EnumOf a

Instances

(Typeable a, Show a, Enum a, Bounded a) => ParsableArgument (EnumOf a)
(Typeable a, Show a, Enum a, Bounded a) => Argument (EnumOf a)

newtype Nat

Constructors

Nat Int

Instances

Enum Nat
Eq Nat
Num Nat
Ord Nat
Show Nat
Typeable Nat
PrettyPrintable Nat
ParsableArgument Nat
Argument Nat

nat :: Int -> Nat

natToInt :: Nat -> Int

Constructors for Arguments

naturalArg :: Arg Nat

Natural argument

boolArg :: Arg Bool

Boolean argument, which is parsed as either On or Off.

maybeArg :: Arg a -> Arg (Maybe a)

Argument, that additionally parses as none.

listArg :: Arg a -> Arg [a]

A list of arguments.

processorArg :: Arg Processor

Processor argument

type EnumArg a = Arg (EnumOf a)

This can be used to lift instances of Typeable, Show, Enum and Bounded to arguments. Suppose you have a datatype like the following.

>>> data MyType = A | B | C deriving (Typeable, Show, Enum, Bounded)

An argument description for an element of type MyType is then given by

>>> arg :: EnumArg MyType

type AssocArg a = Arg (Assoc a)

Construct an argument from an associated list, by declaring a datatype an instance of AssocArgument. Use as follows:

>>> instance AssocArgument MyType where
     assoc _ = [("nameA", valueA), ("nameB", valueB)...]

Then one can use a declaration

>>> arg :: AssocArg MyType

which will parse valueA as nameA, valueB as nameB, and so on.