- Haskell-Cafe - Haskell.org

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

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/ 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 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… 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

Re: [Haskell-cafe] http://www.haskell.org/ghc/reportabug
by Isaac Dupree 30 Jun '08

30 Jun '08

Galchin, Vasili wrote: > Isaac, > > which "different trac page"? I have tried several times to no avail! any one that says you're not logged in. Probably you're having a different problem than I was, if it's that hard to solve... -Isaac

1 0

[Haskell-cafe] Re: blas bindings, why are they so much slower the C?
by patperry＠stanford.edu 30 Jun '08

30 Jun '08

Thanks for the patch, Don. I'm on vacation now, but I'll apply it when I get back. As for why "getDot" involves pattern matching, it is because a vector is either a pointer to raw storage, or a conjugated vector. I wrote a blog post about this for those of you who are interested ( http://quantile95.com/2008/06/12/blas-data-types/ ). The current data type is this: data DVector t n e = DV { fptr :: !(ForeignPtr e) , offset :: !Int , len :: !Int , stride :: !Int } | C !(DVector t n e) Now, it isn't strictly necessary to use an algebraic data type-- I could have just used a boolean flag, but the code is a little cleaner this way. I haven't done any tests to see what the difference in performance is. I would expect that a pattern match between two alternatives would be just as fast as checking a boolean flag. The good news is that this is a constant-time overhead. For larger vectors, getDot should approach the performance of a raw cblas_ddot call. Patrick

1 0

Haskell Related Reading
by Darrin Thompson 29 Jun '08

29 Jun '08

I have a trip coming up and might have some reading time. I was hoping to get through some of the classics, bananas and lenses, the essence, etc. So I have a few questions: Bananas and lenses et. al. uses some notation that I don't understand right out of the gate. Is there a good primer on whatever that brand of double bars and arrows means? The essense of functional programming looks good, I could understand it when I skimmed it but can I print it out on US letter? The PDF at citeseer was aligned badly. (Essece seemed like a fabulous intro or chapter 2 on getting used to monads. Better than most stuff on the web. Funny that...) I'm also interested in FRP as it might relate to web programming. Anyone have a recommendation? -- Darrin

3 2

Ptr Word8 display question
by Galchin, Vasili 29 Jun '08

29 Jun '08

Hi, Suppose I have a value of type Ptr Word8 and also an Int which is the length of the Ptr Word8(sorry if I am thinking too much in a C string frame of mind). How can I display the Ptr Word8 value of the given length? Vasili

2 2

Learning GADT types to simulate dependent types
by Paul Johnson 28 Jun '08

28 Jun '08

I'm trying to understand how to use GADT types to simulate dependent types. I'm trying to write a version of list that uses Peano numbers in the types to keep track of how many elements are in the list. Like this: {-# OPTIONS -fglasgow-exts -fallow-undecidable-instances #-} module Plist where infixr 3 :| data Zero data S a class Add n1 n2 t | n1 n2 -> t, n1 t -> n2 instance Add Zero n n instance Add (S n1) n2 (S t) data Plist n a where Nil :: Plist Zero a (:|) :: a -> Plist n a -> Plist (S n) a instance (Show a) => Show (Plist n a) where show Nil = "Nil" show (x :| xs) = show x ++ " :| " ++ show xs pHead :: Plist (S n) a -> a pHead (x :| _) = x pTail :: Plist (S n) a -> Plist n a pTail (_ :| xs) = xs pConcat Nil ys = ys pConcat (x :| xs) ys = x :| pConcat xs ys Everything works except the last function (pConcat). I figured that it should add the lengths of its arguments together, so I created a class Add as shown in the Haskell Wiki at http://www.haskell.org/haskellwiki/Type_arithmetic. But now I'm stuck. When I try to load this module I get: Plist.hs:32:8: GADT pattern match in non-rigid context for `Nil' Tell GHC HQ if you'd like this to unify the context In the pattern: Nil In the definition of `pConcat': pConcat Nil ys = ys Failed, modules loaded: none. (Line 32 is "pConcat Nil ys = ys") So how do I do this? Am I on the right track? Can someone help improve my Oleg rating? Thanks, Paul.

3 3

Galois move complete, Hackage back online
by Don Stewart 28 Jun '08

28 Jun '08

Galois has completed the move of its data center, and the services: hackage.haskell.org darcs.haskell.org are now back online. Thanks for your patience, everyone! Enjoy the new bandwidth. -- Don

1 0

Hackage
by Cetin Sert 28 Jun '08

28 Jun '08

Hi, Hackage seems to have been down for a few days now. When is it going to be back online? It is not possible to darcs-get any packages either. Best Regards, Cetin Sert

1 0

blas bindings, why are they so much slower the C?
by Anatoly Yakovenko 28 Jun '08

28 Jun '08

here is the C: #include <cblas.h> #include <stdlib.h> int main() { int size = 1024; int ii = 0; double* v1 = malloc(sizeof(double) * (size)); double* v2 = malloc(sizeof(double) * (size)); for(ii = 0; ii < size*size; ++ii) { double _dd = cblas_ddot(0, v1, size, v2, size); } free(v1); free(v2); } this is the haskell: module Main where import Data.Vector.Dense.IO main = do let size = 1024 v1::IOVector Int Double <- newListVector size [0..] v2::IOVector Int Double <- newListVector size [0..] mapM_ (\ ii -> do v1 `getDot` v2) [0..size*size] time ./testdot real 0m0.017s user 0m0.010s sys 0m0.010s time ./htestdot real 0m4.692s user 0m4.670s sys 0m0.030s so like 250x difference htestdot.prof is no help Tue Jun 17 20:46 2008 Time and Allocation Profiling Report (Final) htestdot +RTS -p -RTS total time = 3.92 secs (196 ticks @ 20 ms) total alloc = 419,653,032 bytes (excludes profiling overheads) COST CENTRE MODULE %time %alloc main Main 88.3 83.0 CAF Main 11.7 17.0 individual inherited COST CENTRE MODULE no. entries %time %alloc %time %alloc MAIN MAIN 1 0 0.0 0.0 100.0 100.0 CAF Main 216 7 11.7 17.0 100.0 100.0 main Main 222 1 88.3 83.0 88.3 83.0 CAF GHC.Float 187 1 0.0 0.0 0.0 0.0 CAF GHC.Handle 168 3 0.0 0.0 0.0 0.0

8 12