- Haskell-Cafe - Haskell.org

Unboxed array of product type -> product type of unboxed arrays
by Scott Dillard 02 Jul '08

02 Jul '08

Hi, I'm trying to extended the standard unboxed array types and array classes to my own product types, for now let's just say (,). So if the proper MArray and IArray instances exist for e and f, then I can make an instance for (e,f). The actual type of that array, something like (UArray i e, UArray i f), would be given by an associated type. This is how the uvector library does it, but that library defines its own array primitives and classes. I'd like to reuse the standard ones if possible. The problem I keep running into is the kind of the array, * -> * -> *, or 'a i e'. The crucial type there is e, which is used to dispatch the instance to the proper associated type, so if e = (a,b) then the array type would be (UArray i a, UArray I b), and if e is (a,b,c) then (UArray i a, UArray i b, UArray i c). If IArray was instead expecting the array type to be 'a e i' I could maybe do something like this: class UArrClass e where data UArr e :: * -> * instance (IArray UArray e, IArray UArray f) => UArrClass (e,f) where data UArr (e,f) i = UArrPair (UArray i e) (UArray i f) But as it stands, I can't do that. The 'i' type parameter has to be bound as a parameter of UArrClass. So instead I tried this. class UArrClass i e where data UArr i e unsafeAt_ :: UArr i e -> Int -> e --mirror all IArray methods instance ( IArray UArray e , IArray UArray f , Ix i --needed for unsafeAt ) => UArrClass i (e,f) where newtype UArr i (e,f) = UArrPair (UArray i e) (UArray i f) unsafeAt_ (UArrPair ea fa) i = (unsafeAt ea i , unsafeAt fa i) and then the instance for IArray could be defined as follows, just a mapping from the methods of that class onto my own: instance ( IArray UArray e , IArray UArray f , UArrClass i (e,f) ) => IArray UArr (e,f) where unsafeAt = unsafeAt_ The problem I get now is from the 'Ix i' context of the IArray methods. The 'i' there is only mentioned in the context of the methods, not the class, so I have no 'handle' onto that 'i' that I can use to explicitly unify it with the 'i' mentioned in UArrClass. The compiler keeps complaining about rigid type variables. It would be great if I could leave that type variable unbound in my class, and only bind it in the methods, as IArray does, but as far as I can tell, I can't. I need to bind 'i' in my class because it's the first type-argument to the array type constructor, rather than the second. I don't care about the 'i', its the 'e' I'm after, but all applications of the associated type constructor need to be saturated. Can anyone see a way to do this? I understand there's about a million other ways to accomplish what I'm trying to do without IArray and MArray, but I'm just wondering if I should abandon those classes altogether, and use my own array classes, using something like uvector or unsafeIO/ForeignPtr. That seems to be trend. Thanks, Scott

3 2

Re: [Haskell-cafe] gcc as a portable assembler: tail calls vs trampoline
by Loup Vaillant 01 Jul '08

01 Jul '08

2008/7/1 Robin Green <greenrd(a)greenrd.org>: > I think you should use the -march flag to gcc. Otherwise you are tying > the compiler to an ancient version of the x86 instruction set (386). OK, let's try... Done. I used -march=nocona. I couldn't do core2 (not available on my gcc 4.1.2 yet). Did not notice any difference... > On Tue, 1 Jul 2008 16:57:38 +0200 > "Loup Vaillant" <loup.vaillant(a)gmail.com> wrote: > >> Hello, everyone, >> I'm not sure this is the good list for this posting: I plan to write >> yet another lazy graph reduction machine, using gcc, mainly for fun. >> My concern right now is about one particular aspect of gcc: the tail >> calls vs trampoline deathmatch. >> >> First some clarifications: >> -> By tail call, I mean a properly optimized one, which doesn't grow >> the stack. Basically a jump. >> -> By trampoline, I mean the infinite loop referred to as a "tiny >> interpreter" in the STG paper [1]. Instead of (tail) calling a >> function, we return its pointer, which will then be used for the >> actual call. >> >> I've read that trampoline calls are about 3 times as expensive as tail >> calls. Instead of a (direct) jump, you have a return, followed by an >> indirect call. However, testing this with gcc, I didn't manage to show >> any measurable difference. What am I missing? I used -O2 on both >> benchmarks, and turned off inlining (using the __noinline__ >> attribute). I'm running the program on a core2Duo in 32 bits mode, >> using GNU/Linux Ubuntu. Should I also make separate modules to prevent >> whole program analysis from gcc? >> >> Anyway, I send you the code below, so you can test and review it. >> Enjoy! >> >> [1]: >> http://research.microsoft.com/Users/simonpj/Papers/spineless-tagless-gmachi… >> >> >> >> /* This program tests the performance difference between trampoline >> * calls and tail calls. (In the STG and related papers, trampoline >> * is referred to as "tiny interpreter") >> * >> * depending on the mode (tail call or trampoline), some code changes: >> * the return type of the code blocks, and the calls to other blocks >> * (direct tail calls or return to trampoline). Hence the macros ENTER >> * and RETURN. >> * >> * To compile it,type one of the two following commands: >> * gcc -O2 sibcall.c -D SIBCALL >> * gcc -O2 sibcall.c >> * >> * The first one will make the program use sibling calls (enabled at >> * O2), and the second one will fall back to trampoline calls >> */ >> >> #ifdef SIBCALL // tail call mode >> >> #define ENTER(f) (f()) >> #define RETURN void >> #define MAIN(start) start() >> >> #else // trampoline call mode >> >> #define ENTER(f) return f >> #define RETURN void* >> #define MAIN(start) do{ void * (*f)(void) = start; \ >> while (1) \ >> f = (*f)(); \ >> } while (0) >> #endif >> >> // Now, we can begin the generic code >> #include <stdlib.h> >> #define LIMIT 1000000000 // one billion >> >> int counter = 0; >> >> RETURN closure0(void); >> RETURN closure1(void); >> >> >> int main(int argc, char ** argv) >> { >> MAIN(closure0); >> return 0; >> } >> >> __attribute__ ((__noinline__)) >> RETURN closure0(void) >> { >> if (counter >= LIMIT) exit(0); >> counter++; >> ENTER(closure1); >> } >> __attribute__ ((__noinline__)) >> RETURN closure1(void) >> { >> if (counter >= LIMIT) exit(0); >> counter++; >> ENTER(closure0); >> } >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >

2 1

gcc as a portable assembler: tail calls vs trampoline
by Loup Vaillant 01 Jul '08

01 Jul '08

Hello, everyone, I'm not sure this is the good list for this posting: I plan to write yet another lazy graph reduction machine, using gcc, mainly for fun. My concern right now is about one particular aspect of gcc: the tail calls vs trampoline deathmatch. First some clarifications: -> By tail call, I mean a properly optimized one, which doesn't grow the stack. Basically a jump. -> By trampoline, I mean the infinite loop referred to as a "tiny interpreter" in the STG paper [1]. Instead of (tail) calling a function, we return its pointer, which will then be used for the actual call. I've read that trampoline calls are about 3 times as expensive as tail calls. Instead of a (direct) jump, you have a return, followed by an indirect call. However, testing this with gcc, I didn't manage to show any measurable difference. What am I missing? I used -O2 on both benchmarks, and turned off inlining (using the __noinline__ attribute). I'm running the program on a core2Duo in 32 bits mode, using GNU/Linux Ubuntu. Should I also make separate modules to prevent whole program analysis from gcc? Anyway, I send you the code below, so you can test and review it. Enjoy! [1]: http://research.microsoft.com/Users/simonpj/Papers/spineless-tagless-gmachi… /* This program tests the performance difference between trampoline * calls and tail calls. (In the STG and related papers, trampoline * is referred to as "tiny interpreter") * * depending on the mode (tail call or trampoline), some code changes: * the return type of the code blocks, and the calls to other blocks * (direct tail calls or return to trampoline). Hence the macros ENTER * and RETURN. * * To compile it,type one of the two following commands: * gcc -O2 sibcall.c -D SIBCALL * gcc -O2 sibcall.c * * The first one will make the program use sibling calls (enabled at * O2), and the second one will fall back to trampoline calls */ #ifdef SIBCALL // tail call mode #define ENTER(f) (f()) #define RETURN void #define MAIN(start) start() #else // trampoline call mode #define ENTER(f) return f #define RETURN void* #define MAIN(start) do{ void * (*f)(void) = start; \ while (1) \ f = (*f)(); \ } while (0) #endif // Now, we can begin the generic code #include <stdlib.h> #define LIMIT 1000000000 // one billion int counter = 0; RETURN closure0(void); RETURN closure1(void); int main(int argc, char ** argv) { MAIN(closure0); return 0; } __attribute__ ((__noinline__)) RETURN closure0(void) { if (counter >= LIMIT) exit(0); counter++; ENTER(closure1); } __attribute__ ((__noinline__)) RETURN closure1(void) { if (counter >= LIMIT) exit(0); counter++; ENTER(closure0); }

1 0

lhs syntax highlighting in vim
by Eric Stansifer 01 Jul '08

01 Jul '08

Hello, The syntax highlighting file for literate haskell in vim says that its maintainer is haskell-cafe(a)haskell.org, so hopefully one of you will find this relevant. In literate haskell files, vim optionally highlights the non-code text according to TeX markup. The syntax highlighting file looks for key phrases (e.g., "\documentclass") to decide whether to use TeX markup highlighting; but it (erroneously, in my opinion, and at variance with the documentation) will use TeX markup highlighting on any lhs file that contains the '%' character anywhere in it. The bug is in line 74 of version 1.01 of the lhaskell.vim syntax highlighting file. Thanks, Eric

3 2

The ping method in HDBC
by Agent Zhang 01 Jul '08

01 Jul '08

Hi, there I'm wondering if there's a ping method in HDBC that does the same thing as Perl DBI's ping. Please see the following link for details: http://search.cpan.org/~timb/DBI-1.605/DBI.pm#ping I think It's rather important for database auto-connection when preserving database connections for a quite long time in fastcgi applications. Any ideas? Thanks in advance! -agentzh

2 2

http://www.haskell.org/ghc/reportabug
by Galchin, Vasili 01 Jul '08

01 Jul '08

Hi, When I run my test case, I get timer: internal error: scavenge: unimplemented/strange closure type 60 @ 0x76a28400 (GHC version 6.8.2 for i386_unknown_linux) Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug I went to this URL. I already have an account. I want to see if there is a report on this problem but I get the following message ... TICKET_CREATE privileges are required to perform this operation I read some of the Trac documentation but didn't see what privilege I am missing. ?? Thanks, Vasili

4 9

ANN: Hasim, discrete event simulation in Haskell
by Jochem Berndsen 30 Jun '08

30 Jun '08

Hi all, I've started a small project to create a library to do discrete event simulation in Haskell. Its website is located at http://huygens.functor.nl/hasim . It uses monads to define a domain-specific language for "actions" of a process. The interested reader is referred to the website. Regards, -- Jochem Berndsen | jochem(a)functor.nl GPG: 0xE6FABFAB

1 0

re: [Haskell-cafe] Implementing PADS in Haskell?
by David Walker 30 Jun '08

30 Jun '08

Simon writes: > It's not clear to me > > a) whether or not you want new syntax (requires writing a parser) we are starting out our implementation without special syntactic support, but I do anticipate it will be useful primarily because the implementation I envision will need to generate both datastructures and type declarations. I don't quite see how a combinator library, for instance, can do that. For example, it is very nice for the user to declare a pads datatype like this: pdata Pairs = Myints (Pint, /|/, Pint) | Mychars (Pchar, /|/, Pchar) I would hope the effect of such a declaration would be to do two things. First, generate declaration of a Haskell datatype: data Pairs = Myint (int, int) | Mychars (char, char) and second, generate an instance of the GADT (type Pads a where a is the type of the parsed data) that we are planning to use to represent the PADS descriptions. Functions such as parse, print, toxml, etc. perform walks over the GADT instance. eg: Pairs :: Pads Pairs Pairs = ... bunch of constructor applications to build the GADT representing Pairs ... If I just wanted to build the GADT data structure, I can see how I could define a collection of combinators directly in Haskell to do that. However, I want to build a data structure *and* declare a type. And I want programmers to be able to refer to and use both. I do not see how to get around that. In addition, in order to include arbitrary new datatypes in the GADT that we are using to represent pads, it seems necessary to me at the moment to pull a bit of a hack. For each branch of the datatype, I need to wrap up injection and projection from the datatype in a pair of functions and pass that to a generic GADT constructor. Doing that by hand would seem to incur quite a bit of programming overhead and detract from the pleasure of using datatypes. It may be hard to follow what I am talking about... if people were interested, I could post the GADT definition we are working with in a few days when it is a little bit more settled... In addition to the argument about generating type declarations and data structures at the same time, it would seem to me that doing things like being able to put constant literals and regular expressions inline in a custom syntax will improve the readability and useability of the system. However, this argument is not as strong -- it is definitely true of PADS for C and also, I think for O'Caml, but perhaps if we are creative we can figure out a way to fit what we want elegantly into Haskell syntax. > Concerning (b), if you want to write a program that generates one or more Haskell programs, then > Template Haskell is good. But if you can get away with just one program, then you may not > need that extra complexity. Many domain-specific languages embedded in Haskell use just > Haskell (e.g. Parsec, Fran, Yampa...), not TH nor quasiquotation. By the way, when you use the terminology "embedded domain-specific language" is that really just a synonym for "library"? Is there any difference between an "embedded domain-specific language" and an ordinary library? Thanks, Dave PS: it does not look like my email is getting to the Haskell-cafe mailing list, especially from my gmail account. Is the list moderated? Can that cause a delay? Does this list filter email if the reply-to field is different from the sender? My gmail account is princedpw(a)gmail.com with a reply-to of dpw(a)cs.princeton.edu ... I signed up a second time from my princeton account with email address dpw(a)cs.princeton.edu and same reply-to ... -------------- --------------- hi, I sent the message below to the template Haskell mailing list and it was suggested that I send it to the more general Haskell mailing list. After my question, I attached a few responses I have received. Thanks in advance for any suggestions. Dave ------------------------ I am new to Haskell and even more so to Haskell templates -- if there is an obvious answer to my question, please just point me at the relevant URL. Thanks! (If you think I should email this query to a broader Haskell mailing list let me know too.) My friends and I are thinking about adding an extension to Haskell to implement a variant of the PADS domain-specific language. PADS is a convenient syntax to describe a file format and generate a bunch of tools for it such as parser, printer, xml translator, semi-structured query engine, statistical profiler, etc. (We also have tools to automatically infer descriptions from example data but that's not quite the point here.) See www.padsproj.org/ <http://www.padsproj.org/> <http://www.padsproj.org/> for lots more info and examples of PADS for C and PADS for O'Caml. The bottom line question is I'm wondering if I can or should implement my PADS extension using Template Haskell to support the syntactic extensions. If not Template Haskell, is there another Haskell toolkit I should know about? If Template Haskell isn't powerful enough, I'll probably just write a standalone compiler that parses my special syntax and spits out a file full of Haskell declarations (this would be a slight shame because then I would probably not support writing PADS declarations in the midst of other Haskell code). I've looked at simple Template Haskell examples from the Haskell wiki, such as the printf example, but I need to introduce a lot more syntax than that ... What do I need from Template Haskell? Well what I would like to do is add a bit of syntax to Haskell that allows users to define what looks like non-standard type declarations. The "compiler" for these non-standard type declarations will generate a collection of ordinary Haskell declarations that can be used by a programmer. The non-standard typing declarations will be a mixture of what looks like Haskell type declarations, Haskell code, perl-style syntax for regular expressions and perhaps some other stuff I'm not thinking of right now. For example, suppose I want to write a program that converts a file that contains a list of friends into XML (it's a bit of an artificial example so I can illustrate several features): 3 Simon;Peyton Jones John;Launchbury #Phil;Wadler The format starts with a number on the first line to indicate the number of entries in the file. Each line contains one entry which is a first name then a ';' then a last name. Some lines begin with a # -- they are commented out because I'm no longer friends with them. Naturally, Phil Wadler falls into that category. :-) ! The Haskell program I want to write to do this would look something like: ------------------------- {| pdata Line = Comment /#.*/ | Name {first::Pstr /;/, last ::Pstr /\n/} ptype Friends = (x::Pint, |{ x > 0 }|, /\n/, PlistFW x) |} friendsToXML :: String -> XML friendsToXML s = PADSTools.toXML Friends s ------------------------- Notice the following syntactic features: -- {| and |} are delimiters that begin/end pads code (I don't really care what the delimiters are as long as they are relatively concise. For instance, if the delimiters were $( ... ), for instance, that would be fine. -- inside {| and |}, we can jump back into Haskell by using the delimiters |{ and |} -- there are some built-in, pre-defined base types like Pstr (for parsing and printing strings) and Pint (for parsing and printing integers), PlistFW (which takes an argument x to specify the number of elements in the list) -- regular expressions /..../ show up in the middle of what would otherwise be Haskell type declarations -- there is syntax for declaring datatype-like things (introduced by pdata keyword) -- the declarations are dependent types in that there is binding (eg: the x::Pint in the "Friends" type -- the x is bound here) -- variables bound in pads code can then be used in Haskell code nested inside the declaration (eg: the Haskell expression x > 0 refers to the variable x, defined in the outer pads code). -- the outer Haskell code refers to declarations made inside the PADS code. (eg: the Haskell function "friendsToXML s = PADS.Tools.toXML Friends s" refers to Friends, where Friends would be bound to a datastructure generated by the compiler for the pads code. PADSTools is a module defined a priori that contains a number of functions such as toXML, parse, print, query, etc.) Anyway, if you have any comments on how I should handle the syntactic extensions, let me know. Thanks again, Dave ------------ Ian: You can't create new syntax with TH; it's just Haskell (plus the TH syntactic extensions themselves, i.e. $( e ), and a few variants of [| e |]). You'd have to encode the info into Haskell syntax somehow, e.g. something like $( pdata "Line" [C "Comment" [], C "Name" [ ("first", ["Pstr", "/;"]), ... ) or parse them from strings (which isn't nice either, as Haskell doesn't have nice multi-line strings). Thanks Ian ---------------- From Claus Reinke: well, how about using the new quasiquoting to get HereDocs:-) {-# LANGUAGE TemplateHaskell #-} module Here where import Language.Haskell.TH <http://Language.Haskell.TH> <http://Language.Haskell.TH> import Language.Haskell.TH.Quote here :: QuasiQuoter here = QuasiQuoter (litE . stringL) (litP . stringL) then {-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE TemplateHaskell #-} import Here s = [$here| hello multiline world |] test = lines s gives us *Main> test [" \r"," hello\r"," multiline\r"," world\r"," "] Claus ------------------ From Simon Peyton Jones: Dave It's not clear to me a) whether or not you want new syntax (requires writing a parser) b) whether you want a single description to generate multiple different Haskell programs, or just one Concerning (a), as Claus says if you want special purpose syntax (ie not Haskell) then you need quasiquotation. This is only in the HEAD, not a released GHC, but it works reliably as far as I know. http://www.haskell.org/ghc/dist/current/docs/users_guide/template-haskell.h… <http://www.haskell.org/ghc/dist/current/docs/users_guide/template-haskell.h…> <http://www.haskell.org/ghc/dist/current/docs/users_guide/template-haskell.h… <http://www.haskell.org/ghc/dist/current/docs/users_guide/template-haskell.h…>> Concerning (b), if you want to write a program that generates one or more Haskell programs, then Template Haskell is good. But if you can get away with just one program, then you may not need that extra complexity. Many domain-specific languages embedded in Haskell use just Haskell (e.g. Parsec, Fran, Yampa...), not TH nor quasiquotation. You'd get a 30x wider audience on the Haskell Cafe mailing list, so yes, I'd try there too. Even jumping to Template Haskell as a solution may be premature; I'm not sure. Meanwhile perhaps other TH folk would like to join in? Simon ______________________________ _________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org <mailto:Haskell-Cafe@haskell.org> http://www.haskell.org/mailman/listinfo/haskell-cafe <http://www.haskell.org/mailman/listinfo/haskell-cafe>

1 0

Fwd: [GHC] #2407: internal error
by Galchin, Vasili 30 Jun '08

30 Jun '08

Hello, Please keep in mind I am only trying to help the Haskell effort. I tried to upload/attach a Linux core file to no avail. Vasili ---------- Forwarded message ---------- From: GHC <trac(a)galois.com> Date: Mon, Jun 30, 2008 at 3:49 AM Subject: [GHC] #2407: internal error To: Cc: glasgow-haskell-bugs(a)haskell.org #2407: internal error --------------------------+------------------------------------------------- Reporter: vigalchin | Owner: Type: bug | Status: new Priority: normal | Component: Compiler Version: 6.8.2 | Severity: normal Keywords: | Testcase: Architecture: Unknown | Os: Linux --------------------------+------------------------------------------------- timer: internal error: resurrectThreads: thread blocked in a strange way (GHC version 6.8.2 for i386_unknown_linux) Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug Aborted (core dumped) -- Ticket URL: <http://hackage.haskell.org/trac/ghc/ticket/2407> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

2 1

Implementing PADS in Haskell?
by David Walker 30 Jun '08

30 Jun '08

hi, I sent the message below to the template Haskell mailing list and it was suggested that I send it to the more general Haskell mailing list. After my question, I attached a few responses I have received. Thanks in advance for any suggestions. Dave ------------------------ I am new to Haskell and even more so to Haskell templates -- if there is an obvious answer to my question, please just point me at the relevant URL. Thanks! (If you think I should email this query to a broader Haskell mailing list let me know too.) My friends and I are thinking about adding an extension to Haskell to implement a variant of the PADS domain-specific language. PADS is a convenient syntax to describe a file format and generate a bunch of tools for it such as parser, printer, xml translator, semi-structured query engine, statistical profiler, etc. (We also have tools to automatically infer descriptions from example data but that's not quite the point here.) See www.padsproj.org/ <http://www.padsproj.org/> for lots more info and examples of PADS for C and PADS for O'Caml. The bottom line question is I'm wondering if I can or should implement my PADS extension using Template Haskell to support the syntactic extensions. If not Template Haskell, is there another Haskell toolkit I should know about? If Template Haskell isn't powerful enough, I'll probably just write a standalone compiler that parses my special syntax and spits out a file full of Haskell declarations (this would be a slight shame because then I would probably not support writing PADS declarations in the midst of other Haskell code). I've looked at simple Template Haskell examples from the Haskell wiki, such as the printf example, but I need to introduce a lot more syntax than that ... What do I need from Template Haskell? Well what I would like to do is add a bit of syntax to Haskell that allows users to define what looks like non-standard type declarations. The "compiler" for these non-standard type declarations will generate a collection of ordinary Haskell declarations that can be used by a programmer. The non-standard typing declarations will be a mixture of what looks like Haskell type declarations, Haskell code, perl-style syntax for regular expressions and perhaps some other stuff I'm not thinking of right now. For example, suppose I want to write a program that converts a file that contains a list of friends into XML (it's a bit of an artificial example so I can illustrate several features): 3 Simon;Peyton Jones John;Launchbury #Phil;Wadler The format starts with a number on the first line to indicate the number of entries in the file. Each line contains one entry which is a first name then a ';' then a last name. Some lines begin with a # -- they are commented out because I'm no longer friends with them. Naturally, Phil Wadler falls into that category. :-) ! The Haskell program I want to write to do this would look something like: ------------------------- {| pdata Line = Comment /#.*/ | Name {first::Pstr /;/, last ::Pstr /\n/} ptype Friends = (x::Pint, |{ x > 0 }|, /\n/, PlistFW x) |} friendsToXML :: String -> XML friendsToXML s = PADSTools.toXML Friends s ------------------------- Notice the following syntactic features: -- {| and |} are delimiters that begin/end pads code (I don't really care what the delimiters are as long as they are relatively concise. For instance, if the delimiters were $( ... ), for instance, that would be fine. -- inside {| and |}, we can jump back into Haskell by using the delimiters |{ and |} -- there are some built-in, pre-defined base types like Pstr (for parsing and printing strings) and Pint (for parsing and printing integers), PlistFW (which takes an argument x to specify the number of elements in the list) -- regular expressions /..../ show up in the middle of what would otherwise be Haskell type declarations -- there is syntax for declaring datatype-like things (introduced by pdata keyword) -- the declarations are dependent types in that there is binding (eg: the x::Pint in the "Friends" type -- the x is bound here) -- variables bound in pads code can then be used in Haskell code nested inside the declaration (eg: the Haskell expression x > 0 refers to the variable x, defined in the outer pads code). -- the outer Haskell code refers to declarations made inside the PADS code. (eg: the Haskell function "friendsToXML s = PADS.Tools.toXML Friends s" refers to Friends, where Friends would be bound to a datastructure generated by the compiler for the pads code. PADSTools is a module defined a priori that contains a number of functions such as toXML, parse, print, query, etc.) Anyway, if you have any comments on how I should handle the syntactic extensions, let me know. Thanks again, Dave ------------ Ian: You can't create new syntax with TH; it's just Haskell (plus the TH syntactic extensions themselves, i.e. $( e ), and a few variants of [| e |]). You'd have to encode the info into Haskell syntax somehow, e.g. something like $( pdata "Line" [C "Comment" [], C "Name" [ ("first", ["Pstr", "/;"]), ... ) or parse them from strings (which isn't nice either, as Haskell doesn't have nice multi-line strings). Thanks Ian ---------------- From Claus Reinke: well, how about using the new quasiquoting to get HereDocs:-) {-# LANGUAGE TemplateHaskell #-} module Here where import Language.Haskell.TH <http://Language.Haskell.TH> import Language.Haskell.TH.Quote here :: QuasiQuoter here = QuasiQuoter (litE . stringL) (litP . stringL) then {-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE TemplateHaskell #-} import Here s = [$here| hello multiline world |] test = lines s gives us *Main> test [" \r"," hello\r"," multiline\r"," world\r"," "] Claus ------------------ From Simon Peyton Jones: Dave It's not clear to me a) whether or not you want new syntax (requires writing a parser) b) whether you want a single description to generate multiple different Haskell programs, or just one Concerning (a), as Claus says if you want special purpose syntax (ie not Haskell) then you need quasiquotation. This is only in the HEAD, not a released GHC, but it works reliably as far as I know. http://www.haskell.org/ghc/dist/current/docs/users_guide/template-haskell.h… <http://www.haskell.org/ghc/dist/current/docs/users_guide/template-haskell.h…> Concerning (b), if you want to write a program that generates one or more Haskell programs, then Template Haskell is good. But if you can get away with just one program, then you may not need that extra complexity. Many domain-specific languages embedded in Haskell use just Haskell (e.g. Parsec, Fran, Yampa...), not TH nor quasiquotation. You'd get a 30x wider audience on the Haskell Cafe mailing list, so yes, I'd try there too. Even jumping to Template Haskell as a solution may be premature; I'm not sure. Meanwhile perhaps other TH folk would like to join in? Simon

1 0