 | SybWidget-0.5.0: Library which aids constructing generic (SYB3-based) widgets | Contents | Index |
| Graphics.UI.SybWidget.SybOuter |
| Contents |
Helper functions to creates generic widgets.
The parent type, which is refered thoughout the module documentation, could also be called the enclosing type. For example given:
data Foo = Foo Bar Boo
then the parent type of Bar and Boo will be Foo.
| class OuterWidget outer where | ||||
| ||||
data FullPart wid parent b = FullPart {
| ||||
| mkGetterSetter :: forall ctx wid getM setM parent. (Monad getM, Monad setM, Data ctx parent) => Proxy ctx -> (forall a. wid a -> getM a) -> (forall a. wid a -> a -> setM ()) -> Spliter wid parent parent -> (getM parent, parent -> setM ()) | ||||
| mkFullSpliter :: forall ctx parent part. Data ctx parent => Proxy ctx -> Spliter part parent parent -> Spliter (FullPart part parent) parent parent | ||||
| isSingleConstructor :: Data ctx a => Proxy ctx -> a -> Bool | ||||
| mkSpliterSingleConstr :: forall ctx a outer. (Data ctx a, OuterWidget outer) => Proxy ctx -> (forall a1. Data ctx a1 => a1 -> outer a1) -> a -> Spliter outer a a | ||||
| ||||
| mapParts :: forall partA partB parent. (forall q. Typeable q => partA q -> partB q) -> Spliter partA parent parent -> Spliter partB parent parent | ||||
| mapPartsM :: forall partA partB parent m. Monad m => (forall q. Typeable q => partA q -> m (partB q)) -> Spliter partA parent parent -> m (Spliter partB parent parent) | ||||
| mapPartsMDelay :: forall partA partB parent m. Monad m => (forall q. Typeable q => partA q -> Bool) -> (forall q. Typeable q => partA q -> m (partB q)) -> Spliter partA parent parent -> m (Spliter partB parent parent) | ||||
| spliterToList :: forall c. Typeable c => part c -> abstractPart -> Spliter part a b -> [abstractPart] | ||||
| zipSpliterWithList :: forall a m n part. (forall q. Typeable q => a -> part q -> part q) -> [a] -> Spliter part m n -> Spliter part m n | ||||
| mkConstrValMap :: (Data ctx a, RefMonad m ref) => Proxy ctx -> a -> m (ConstrValMap ref ctx a) | ||||
| updateConstrValMap :: (Data ctx a, RefMonad m ref) => ConstrValMap ref ctx a -> a -> m () | ||||
| lookupValue :: (Data ctx a, RefMonad m ref) => ConstrValMap ref ctx a -> Constr -> m (Maybe a) | ||||
| alwaysValue :: (Data ctx a, RefMonad m ref) => ConstrValMap ref ctx a -> Constr -> m a | ||||
| data ConstrValMap ref ctx a | ||||
| numericGetSet :: (Data ctx a, RefMonad m ref) => Proxy ctx -> a -> m (String -> m a, a -> m String) | ||||
| sybRead :: Data ctx a => Proxy ctx -> a -> String -> Maybe a | ||||
| sybShow :: Data ctx a => Proxy ctx -> a -> String | ||||
| typeLabel :: Data ctx a => Proxy ctx -> a -> PriLabel |
| Methods | |
|
The Splitter type contains the splitting of a type into a Constructor and Parts. The Spliter structure is reverse, in the sense that a type C a b c, where C is a constructor and a, b and c is values to the constructor, will be represented as (Splitter type in brackets): (Part (part c) { C a b c } (Part (part b) { c -> C a b c } (Part (part a) { b -> c -> C a b c } (Constructor C)))) { a -> b -> c -> C a b c } | ||||
| Constructors | ||||
|
Monadic version of mapParts. The mapping is done deep first. It is done deep first as we will then process the elements in the field order. E.g. if the spliter is based on the:
data Foo = Foo Int Double
then the Int will be processed first, then the Double.
Like mapPartsM, except that processing of certain parts can be delayed. The first parameter decides which parts processing should be delayed.
This is usefull when fine grained control of execution order is desired.
| :: | |
| => forall c. Typeable c => part c -> abstractPart | Function to transform each part in the spliter to a list element. Note that the parts have kind * -> *, but the output must be of kind *. |
| -> Spliter part a b | |
| -> [abstractPart] | |
| Transforms a spiltter to a list. The list will follow the constructor fields order. | |
Returns a getter and setter command for numeric types. The getter and setter are applicable when numeric types are represented using String. The function uses sybRead and sybShow to parse and construct strings. In this way we avoid dependency on Show and Read type classes.
It is generally a good idea to avoid dependencies. And it can be essential to avoid dependency on Show and Read, if we want to implement generic widgets for functions, as we cannot define Show and Read for those.
It could be argued that Int, Double, Float, .. all are instances of Read and Show, and it therefore unneccesary to avoid using these classes. However, SYB will force any dependencies for these types on all types for which we want generic functionality. SYB does that as we make one piece of code handling all integer-like types, and one handling all real-numbered types. Thus, we only have access to the classes that are in the generic class's context.
The getter uses the last legitimate value when the input string is non-parseable.
Avoid dependency on the Read class, by using SYB to read a value. It has _only_ been tested for numeric types.
See also numericGetSet.
Avoid dependency on the Show class, by using SYB to show a value. It has _only_ been tested for numeric types.
See also numericGetSet.