Hi. Some time ago I forgot to forward this message to thie ur versus Haskell http://www.haskell.org/pipermail/haskell-cafe/2011-January/088060.htmldiscussion, (as usual) --- The most impressive feature (of ur) is the compile time checking of conformance between the form and the form results. This can be done in Haskell using HList magic and some class instances, I guess. ---- Since then I have been playing mentally with this. Recently I found something simple an interesting enough to share. (Although crude). It is a kind of typed form fields data Input a= Input String Type a (String -> Either String a) and a kind of heterogeneous list to aggregate form fields and results with the operator (:*): Input a :* Input b ;* Input c.... a :* b :* c and a (simulated for the purpose of demonstration) send-receive function that type match the form fields and the results: *Main> let form = Input "" Text "stringdata" novalidate :* Input "" Text (1::Integer) novalidate *Main> ask form >>= \(a :* b) -> return $ a ++ b <interactive>:1:0: No instance for (FormDigest (Input [Char] :* Input Integer) ([a] :* [a])) ...... notifying that there is no translation defined , because the result requires two lists of the same type when the form gives a string and an Integer But forcing the correct monomorphic types it does pattern match and return the values. *Main> ask form >>= \ (a :* b) -> print ('s':a) >> print ( fromInteger $ b) "sstringdata" 1 ask is just a simulation of HTTP one time interaction. It returns the input values. The whole loop involves the rendering of the form, with render: *Main> render form <input type="Text" name="var1" value="stringdata"/> <input type="Text" name="var2" value=1/> In a real case the results are read and validated from the the post values.They are (or can be) ordered sequentially acording with Input field names. The FormDigest instances do this work. There is no need to define new FormDigest instances. (although non one to one field-result can be created) The text is in literate haskell. There is a more elaborate example at the end. I know that the instances are non tail recursive and there are factorization pending but this is just a proof of concept:

{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, TypeOperators #-}

import Control.Monad.State

The Heterogeneous list agregator. I tried to use GADTs but they does not easily pattern match

data x :* xs = x :* xs deriving (Read, Show, Eq) infixr 5 :*

data Type= Hidden | Text deriving (Show, Read) -- to add all the types

the input field, with text formatting, initial value and runtime validator

data Input a = Input String Type a (String -> Either [String] a)

instance(Show a)=> Show (Input a) where show (Input _ _ x _) = show x

rendering of the form need a sequentiation of field names. I use a state monad for this

class RenderForm a where renderForm :: a -> State Int String

instance (Show a) => RenderForm (Input a) where renderForm input = do s1 <- render1 input n <- get put $ n + 1 return s1

HList school here:

instance (Show a,RenderForm xs) => RenderForm (Input a :* xs) where renderForm (input :* xs)= do n <- get put $ n+1 h <- render1 input s <- renderForm xs return $ h++s

render1 (Input msg t x _)= do n <- get put $ n+1 return $ msg ++ "\n"

render form= putStrLn $ evalState (renderForm form ) 0

processing of the returned form result, in an ordered String list, according with seuquential names of the fields defined in renderForm.

class FormDigest a b where formDigest :: a -> [String] -> Either [String] b

"Input a" is diggested into a type "a"

instance FormDigest (Input a) (a) where formDigest (Input _ _ x f) (s: ss)= case f s of Right x -> Right $ x Left x -> Left x

recursively add instances for any list of inputs Input a's are diggested into a's

instance FormDigest as bs => FormDigest (Input a :* as) (a :* bs) where formDigest (input :* fs) es@(s:ss) = let er = formDigest fs ss e = formDigest input es in case (e, er) of (Right x, Right ys) -> Right $ x :* ys (Right _, Left errs) -> Left errs (Left err, Left errs) -> Left (err ++ errs)

simulated request-response that returns the entered input values

sendRec xs= do let strs = showValues xs return $ formDigest xs strs

class ShowValues a where showValues :: a -> [String]

instance Show x => ShowValues (Input x) where showValues i = [show i ]

instance (Show x,ShowValues xs) => ShowValues (Input x :* xs) where showValues (i :* xs)= show i : showValues xs

end of simulated request response

ask :: (ShowValues a, FormDigest a b) => a -> IO b ask form = do er <- sendRec form case er of Left errs -> error "" -- shoud be: "ask1 errs form "·to render form and errors Right res -> return res

EXAMPLE:

data Emp= Emp{name::String, salary :: Int} deriving Show

emp= Emp "Luis" 10000

toy html operators:

b msg = ("<b> " ++ msg ++ " </b>\n") p msg = ("<p> " ++ msg ++ " </p>\n")

novalidate n= Right $ read n

main= do

let form = Input ( b "please enter the name" ++ p "mas texto") Text (name emp) novalidate :* Input (b "please enter the salary" ++ p "jkjkjk") Text (salary emp) novalidate

render form

the matching thing

(n :* s ) <- ask form

print emp print $ Emp n s