Yes, or better: gshow' :: Data a => a -> String gshow' t = fromMaybe (showConstr(toConstr t)) (cast t) (which gets rid of the parentheses around numbers). Still doesnt get a deserialize though ;-) On 6/24/07, Andrea Vezzosi wrote:

As a side note i'd like to point out that introspectData has a problem with constructors containing Strings because show (x::String) /= x:

data Foo = Foo { bar :: String } deriving (Typeable,Data)

introspectData (Foo "quux") --> [("bar","\"quux\"")]

Those extras \" don't look very nice in the xml.. (the output of introspectData is also wrong in the article's example ) you should probably use a modified gshow:

gshow' :: Data a => a -> String gshow' x = fromMaybe (gshow x) (cast x)

which is id for Strings.

On 6/25/07, Udo Stenzel wrote:

That type signature describes a function that can deliver *anything* (that is in class Data), whatever you ask from it.

Yes, that is the goal :-)

If you do that, you wind up dragging in all the machinery of Data.Generic

Is reflection hard in Haskell? In C# its easy, and its one of the most powerful features of C# just to implement what HaXml does with much

simpler technology. I doubt that's what you actually want.

It is exactly what I want ;-) haxml needs a DTD. On the other hand, I might be misunderstanding. In that case,

Data.Generics should have everything you need, in particular gunfold and friends.

Yes, but I'm kindof stuck giving useful input to makeConstrM, so if anyone has any ideas? kpreid in irc gave me an example of using makeConstrM for a pair of strings , but I cant seem to generalize it to work with a custom data type containing strings and ints ( eg Config{ login :: String, maxLogAgeDays :: Int } ) Current (not working) code looks something like the following. Most of the working bits of testConstrM' / runM' come from kpreid, the rest is my feeble attempts to tweak it. runM' :: (MonadState [String] m, Monad m, Data a) => m a runM' = do value <- gets head modify tail -- then one of: (pick the non-working function of your choice ;-) : -- return read (fromJust value) -- return (fromJust $ cast value ) -- return (fst $ head $ gread( "(" ++ value ++ ")" ) ) -- return (fromConstrM runM' constr) -- return (fromConstr contr) testConstrM' :: (Read a, Data a, Read c, Read b, Data b, Data c) => [String] -> a -> (b,c) testConstrM' fieldvalues object = evalState( fromConstrM runM' (toConstr object) ) fieldvalues data Config = Config{ name :: String, age :: Int } deriving( Data, Show, Typeable, Ord, Eq, Read ) createConfig = Config "blah" 3 test = testConstrM' ["qsdfqsdf", "7"] createConfig (I've left out the xml parsing bit, which you can find at: http://www.haskell.org/haskellwiki/HXT section 9.1.1/9.1.2) Maybe I should escalate the question to the haskell@haskell.org group?

Still struggling with this. If anyone has any constructive ideas? I guess it's not really easy otherwise someone would have come up with a solution by now ;-) The issue is the line in makeConstrM'' where we're trying to read (Data a => a) from (String). "read" doesnt work, because read needs a to be an instance of Read, and Data a does not enforce this. Whilst the parent class can be enforced to be Read, there's nothing to enforce this on the child. Anyway, took a look at SYB3, which came up with this little bit of code: class Data a => StringParser a where parsestring :: String -> a parsestring x = fst $ head $gread(x) instance StringParser Int where parsestring x = read x instance StringParser String where parsestring x = read( "\"" ++ x ++ "\"" ) That looks like it should fix the problem with trying to read primitive child data types: we have a function "parsestring" with various custom methods for each data type we want to handle. On the face of it, it should work with any data type that is an instance of DAta, because of the default parsestring function. Unfortunately (and strangely) not: only data types explicitly added as instances will work with the default function for the Data class, even if the datatypes are in fact members of Data, and logically quite capable of running the default function. So, we cant use this for our Data a=> String -> a function There's a bunch of "ext" functions that look potentially useful, but didnt manage to get any of them to work for this. If anyone has any ideas? For the moment, the only functions that build are: return (fromJust $ fst $ head $ gread( "(" ++ (fromJust value) ++ ")" ) ) or: return ((fromJust . cast) value) ... and neither of these work very well. The second works for strings only, not for other datatypes. The first just plain doesnt seem to work, for some reason. (By the way, if anyone knows how to extract debug information from partially executed functions that would be useful). Here's testConstrM'' at the moment: testConstrM'' :: forall a. (Data a,Read a, Show a) => a -> [(String, Maybe String, DataType,Constr)] -> a testConstrM'' templateobject fieldvalues = evalState (fromConstrM (do --value <- gets head (fieldname,value,datatype,constr) <- gets head modify tail --return (fromJust $ (readConstr datatype value) ) --return (parsestring (fromJust value)) --return (extR (fromJust $ fst $ head $ gread( "(" ++ (fromJust value) ++ ")" ) ) parsestring(fromJust value ) ) return (fromJust $ fst $ head $ gread( "(" ++ (fromJust value) ++ ")" ) ) --return ((fromJust . cast) value) --case constr of -- (toConstr(3::Int)) -> return ((fromJust . cast) value) --IntConstr x -> return ((fromJust . cast) value) --_ -> return ((fromJust . cast) value) --return (read_helper fieldname value datatype) )(toConstr templateobject)) fieldvalues You feed it a template object with the appropriate type, and an array of tuples with the fieldname, fieldvalue, datatype and constructor (we only use the fieldvalue at the moment, so you can leave the others blank).

Hello Hugh, Sunday, July 1, 2007, 8:56:05 PM, you wrote:

Genuine question: please could you tell me what are the truly powerful features of Haskell?

Anyway, getting back to my question, there's a whole slew of articles around saying that no-one uses Haskell because they're too stupid.  That's certainly an argument, but it possibly lacks a certain objectivity ;-)

i agree with it. haskell represents new programming paradigm and most programmers are unable to learn it without help of college in other words, there is not yet enough learning infrastructure for FP languages. the same situation was in 80s for OOP languages. this means that learning FP require much more work, or, spending the same time, one will learn FP much worse than OOP

So... what do you see as the "Killer Advantages" that make Haskell stand out from the pack?

i've written 8kloc "real world" program in haskell and can say what was killer features for me: - natural data structures and easiness of defining algorithms - rich set of list operations - easiness of use of higher-level functions - type inference (dropping almost all declarations) - strong type checking detects many errors just at compile time - non-updateable data simplifies algorithms development for concurrent programming: - it's easy to split algorithm to several parts that are run concurrently and exchange data - channels allows to organize data streams (like Unix pipes) between threads, non-updatability of data significantly simplifies usage of these data - MVar allows to implement shared updateable variables which automatically locks on their use shortly said, non-updatability of data significantly simplifies both usual programming and concurrency, especially later. you can do the same with C# it's an example how i use concurrency for data archiving and compression: - first thread scans disk and finds files to compress. it sends filenames to its output stream - second thread reads contents of these files and sends memory buffers filled with data read to its output stream. it also runs background decompression stream which decompress data from old archive - third thread runs one or several C streams which compress its input buffers and sends buffers with compressed data to output stream. it may be several threads that do it, making a pipe - fourth thread writes compressed data to output archive all four threads are started by line runP$ scanning |> reading |> compression |> writing where each thread represented by a function which has additional argument for exchanging data with previous and next thread in list: reading pipe = do nextFile <- readP pipe .... writeP pipe buffer running additional background thread and exchanging information with it is also trivial: decompressor <- runAsyncP decompressor writeP decompressor request buffer <- readP decompressor you can see module which implements this as Process.hs from http://www.haskell.org/bz/FreeArc-sources.tar.gz although it's actually only a thin layer around forkIO/Chan/MVar features you can do the same in C# although i guess that syntax overhead will be a bit more and allocating a lot of small non-updateable values may be less efficient because its GC isn't aimed to such usage btw, are you read Hoar's book "Communicating Sequential Processes"? i think that his model is very FPish and reading his book should allow to switch your look at concurrency in right direction -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

Well, figured out a solution to parsing xml. It's not really pretty, but it works. Basically we just convert the incoming xml into a gread compatible format then use gread :-D If someone has a more elegant solution, please let me know. module ParseXml where import IO import Char import List import Maybe import Data.Generics hiding (Unit) import Text.XML.HXT.Arrow hiding (when) data Config = Config{ name :: String, age :: Int } --data Config = Config{ age :: Int } deriving( Data, Show, Typeable, Ord, Eq, Read ) createConfig = Config "qsdfqsdf" 3 --createConfig = Config 3 gshow' :: Data a => a -> String gshow' t = fromMaybe (showConstr(toConstr t)) (cast t) -- helper function from http://www.defmacro.org/ramblings/haskell-web.html introspectData :: Data a => a -> [(String, String)] introspectData a = zip fields (gmapQ gshow' a) where fields = constrFields $ toConstr a -- function to create xml string from single-layer Haskell data type xmlSerialize object = "<" ++ show(toConstr object) ++ ">" ++ foldr (\(a,b) x -> x ++ "<" ++ a ++ ">" ++ b ++ "") "" ( introspectData object ) ++ "" -- parse xml to HXT tree, and obtain the value of node "fieldname" -- returns a string getValue xml fieldname | length(resultlist) > 0 = Just (head resultlist) | otherwise = Nothing where resultlist = (runLA ( constA xml >>> xread >>> deep ( hasName fieldname ) >>> getChildren >>> getText ))[] -- parse templateobject to get list of field names -- apply these to xml to get list of values -- return (fieldnames list, value list) xmlToGShowFormat :: Data a => String -> a -> String xmlToGShowFormat xml templateobject = go where mainconstructorname = (showConstr $ toConstr templateobject) fields = constrFields $ toConstr templateobject values = map ( \fieldname -> getValue xml fieldname ) fields datatypes = gmapQ (dataTypeOf) templateobject constrs = gmapQ (toConstr) templateobject datatypereps = gmapQ (dataTypeRep . dataTypeOf) templateobject fieldtogshowformat (value,datatyperep) = case datatyperep of IntRep -> "(" ++ fromJust value ++ ")" _ -> show(fromJust value) formattedfieldlist = map (fieldtogshowformat) (zip values datatypereps) go = "(" ++ mainconstructorname ++ " " ++ (concat $ intersperse " " formattedfieldlist ) ++ ")" xmlDeserialize xml templateobject = fst $ head $ gread( xmlToGShowFormat xml templateobject) dotest = xmlDeserialize (xmlSerialize createConfig) createConfig :: Config dotest' = xmlDeserialize ("<Config><age>12</age><name>test name!</name></Config>") createConfig :: Config

Coooolll :-) Thanks for the link. Ermmmm.... are you the Philip Armstrong I was at college with????

lol small world :-) On 7/2/07, Philip Armstrong wrote:

On Mon, Jul 02, 2007 at 12:23:36AM +0200, Hugh Perkins wrote:

...

Coooolll :-) Thanks for the link.

Ermmmm.... are you the Philip Armstrong I was at college with????

Shhh. Don't tell everyone or they'll all want one. (iow, yes: Probably.)

Phil