- Haskell-Cafe - Haskell.org

Aggressive inlining
by Blue Steel 19 Nov '03

19 Nov '03

I'm working on a parlor trick. I would like to solve a 3-SAT problem at compile time, so that the executable is super fast. Consider --------------------------------------------------- formula (x1,x2,x3) = (x1 || x2) && x3 tf = [True, False] assignments = [(x1,x2,x3)|x1<-tf,x2<-tf,x3<-tf] solutions = filter formula assignments main = do print solutions --------------------------------------------------- Theoretically, a compiler could optimize this to --------------------------------------------------- main = do print [(True,True,True),...] --------------------------------------------------- Is this actually possible in GHC? I've played with inline pragmas and looked at -ddump-..., but I haven't made much progress. Of course, the goal is to replace "formula" with a formula that takes a 30-tuple instead of a triple and really let GHC crank. Thanks for any help. __________________________________ Do you Yahoo!? Protect your identity with Yahoo! Mail AddressGuard http://antispam.yahoo.com/whatsnewfree

1 0

Re: Haskell Server Pages
by Niklas Broberg 19 Nov '03

19 Nov '03

I am part of a project working on an implementation of an HSP system, very much inspired by the paper you mention by Eric Meijer and Daan Leijen. It is our goal to make a complete HSP system with a model for HTML in Haskell, a pre-processor, and a runtime system/plugins for various web servers. The ETA is set to May -04, until then you can follow our progress at http://www.dtek.chalmers.se/~d00nibro/hsp/ There is a simple version of a pre-processor available from our Download page, but use it at your own risk ;) /Niklas _________________________________________________________________ MSN 8 with e-mail virus protection service: 2 months FREE* http://join.msn.com/?page=features/virus

1 0

Partially ordered collections (revisited)
by Graham Klyne 19 Nov '03

19 Nov '03

I've taken the suggestions made by Tom and Robert and combined them into a new module with some supporting functions and test cases. A copy is attached, in case it's of use to anyone. #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

Haskell Server Pages
by "Grigory Makeev 19 Nov '03

19 Nov '03

Hello, I'm interested in writing a personal home-page in a functional way, and i'm in need of some clues. Is there any resource, devoted exactly to the functional approaches to the web programming and web design? I've seen a WASH project, but i'm not really saticefied with the way pages look there. What i trully need is something like Haskell Server Pages system, from Erik Meijer's "Haskell Server Pages. Functional programming and the Battle for the Middle Tier" paper, but i haven't found any implementation of that. I'm not very good at either web programming, or Haskell, i'm just a fan of it, and there's no way i can implement that myself. Is anyone writing currently something like table = <table border="1"> <% mkRows cells%></table> Can anyone provide me with some links? Best regards, Grigory

1 0

Haskell Server Pages
by "Grigory Makeev 19 Nov '03

19 Nov '03

Hello, I'm interested in writing a personal home-page in a functional way, and i'm in need of some clues. Is there any resource, devoted exactly to the functional approaches to the web programming and web design? I've seen a WASH project, but i'm not really saticefied with the way pages look there. What i trully need is something like Haskell Server Pages system, from Erik Meijer's "Haskell Server Pages. Functional programming and the Battle for the Middle Tier" paper, but i haven't found any implementation of that. I'm not very good at either web programming, or Haskell, i'm just a fan of it, and there's no way i can implement that myself. Is anyone writing currently something like table = <table border="1"> <% mkRows cells%></table> Can anyone provide me with some links? Best regards, Grigory

1 0

oh, i'm sorry for doubling a message
by "Grigory Makeev 19 Nov '03

19 Nov '03

1 0

There is flexible exception handling in Haskell?
by 7253146＠informatica.alumnos.uma.es 18 Nov '03

18 Nov '03

Hi all. I am porting to Haskell a small zlib-based library for .zip files (I have not seen any released package for it, although it should very useful). The matters come when I try to address exceptional conditions: all the library functions return a integer code with OK/SOMEERROR meaning. The most natural way to carry the exceptional situations should be raise IO exceptions, but here comes the problem: how can I define new Exception codes, instead of raising userError all the time? I think it makes sense for a library to raise specialized exceptions, instead of userErrors. There is such a mechanism? Can someone help? Thanks. --------------------------------------------- Este mensaje lo ha enviado un Alumno de la Universidad de Malaga. http://www.alumnos.uma.es/

4 3

Subsumption in partially ordered sets
by Graham Klyne 18 Nov '03

18 Nov '03

I have a need for an algorithm to perform "subsumption" on partially ordered sets of values. That is, given a selection of values from a partially ordered set, remove all values from the collection that are less than some other member of the collection. Below is some code I have written, which works, but I'm not sure that it's especially efficient or elegant. Are there any published Haskell libraries that contain something like this? #g -- (The implementation here is based on values of type (Eq a) => [Maybe a], where the partial ordering is defined by function 'pcompare'. Function dropSubsumed (and helpers) is the subsumption calculation. testds1, testds2, testds3, testds4, testds5 are test cases, and all should be True.) [[ -- Type for result of partial order comparison (PNR is no-relationship) data PartOrdering = PLT | PEQ | PGT | PNR deriving (Eq, Show) -- Drop tuples from the supplied list that are subsumed by -- more specific ones. -- dropSubsumed :: (Eq a) => [[Maybe a]] -> [[Maybe a]] dropSubsumed [] = [] dropSubsumed [a] = [a] dropSubsumed (a1:as) = dropSubsumed1 a1 as dropSubsumed1 a1 [] = [a1] dropSubsumed1 a1 (a2:a2s) = case pcompare a1 a2 of PEQ -> dropSubsumed1 a1 a2s PGT -> dropSubsumed1 a1 a2s PLT -> dropSubsumed1 a2 a2s PNR -> dropSubsumed2 [] a1 $ dropSubsumed1 a2 a2s -- Merge new head element into list from which subsumed elements -- have already been removed. The extra (first) parameter is used -- to construct a result in which the order of remaining elements -- is preserved with respect to the original list. dropSubsumed2 a1s a [] = a : revConcat a1s [] dropSubsumed2 a1s a ar@(a2:a2s) = case pcompare a a2 of PEQ -> a : revConcat a1s a2s PGT -> a : revConcat a1s a2s PLT -> revConcat a1s ar PNR -> dropSubsumed2 (a2:a1s) a a2s revConcat :: [a] -> [a] -> [a] revConcat [] a2s = a2s revConcat (a1:a1s) a2s = revConcat a1s (a1:a2s) -- Perform subsumption calculation between a pair of tuples -- A tuple with more information subsumes a one with less but -- consistent information. -- pcompare :: (Eq a) => [Maybe a] -> [Maybe a] -> PartOrdering pcompare a1s a2s = pcompare1 a1s a2s PEQ pcompare1 [] [] po = po pcompare1 (Just _:a1s) (Nothing:a2s) po = if (po == PEQ) || (po==PGT) then pcompare1 a1s a2s PGT else PNR pcompare1 (Nothing:a1s) (Just _:a2s) po = if (po == PEQ) || (po==PLT) then pcompare1 a1s a2s PLT else PNR pcompare1 (a1:a1s) (a2:a2s) po = if a1 == a2 then pcompare1 a1s a2s po else PNR pcompare1 _ _ _ = PNR testds1 = ds1a == ds1b ds1a = dropSubsumed [ [Just 'a',Just 'b',Just 'c'] , [Just 'a',Just 'b',Nothing ] , [Just 'a',Nothing ,Just 'c'] , [Just 'a',Nothing ,Nothing ] , [Nothing ,Just 'b',Just 'c'] , [Nothing ,Just 'b',Nothing ] , [Nothing ,Nothing ,Just 'c'] , [Nothing ,Nothing ,Nothing ] ] ds1b = [ [Just 'a',Just 'b',Just 'c'] ] testds2 = ds2a == ds2b ds2a = dropSubsumed [ [Just 'a',Just 'b',Nothing ] , [Just 'a',Nothing ,Just 'c'] , [Just 'a',Nothing ,Nothing ] , [Nothing ,Just 'b',Just 'c'] , [Nothing ,Just 'b',Nothing ] , [Nothing ,Nothing ,Just 'c'] , [Nothing ,Nothing ,Nothing ] ] ds2b = [ [Just 'a',Just 'b',Nothing ] , [Just 'a',Nothing ,Just 'c'] , [Nothing ,Just 'b',Just 'c'] ] testds3 = ds3a == ds3b ds3a = dropSubsumed [ [Just "a1",Just "b1",Just "c1"] , [Just "a2",Just "b2",Nothing ] , [Just "a3",Nothing ,Just "c3"] , [Just "a4",Nothing ,Nothing ] , [Nothing ,Just "b5",Just "c5"] , [Nothing ,Just "b6",Nothing ] , [Nothing ,Nothing ,Just "c7"] , [Nothing ,Nothing ,Nothing ] ] ds3b = [ [Just "a1",Just "b1",Just "c1"] , [Just "a2",Just "b2",Nothing ] , [Just "a3",Nothing ,Just "c3"] , [Just "a4",Nothing ,Nothing ] , [Nothing ,Just "b5",Just "c5"] , [Nothing ,Just "b6",Nothing ] , [Nothing ,Nothing ,Just "c7"] ] testds4 = ds4a == ds4b ds4a = dropSubsumed [ [Just 1, Just 1 ] , [Just 2, Nothing] , [Nothing,Just 3 ] , [Nothing,Nothing] ] ds4b = [ [Just 1, Just 1 ] , [Just 2, Nothing] , [Nothing,Just 3 ] ] -- Check handling of equal values testds5 = ds5a == ds5b ds5a = dropSubsumed [ [Just 1, Just 1 ] , [Just 2, Nothing] , [Nothing,Just 3 ] , [Nothing,Nothing] , [Just 1, Just 1 ] , [Just 2, Nothing] , [Nothing,Just 3 ] ] ds5b = [ [Just 1, Just 1 ] , [Just 2, Nothing] , [Nothing,Just 3 ] ] ]]

4 4

There is flexible exception handling in Haskell?
by 7253146＠informatica.alumnos.uma.es 17 Nov '03

17 Nov '03

Hi all. I am porting to Haskell a small zlib-based library for .zip files (I have not seen any released package for it, although it should very useful). The matters come when I try to address exceptional conditions: all the library functions return a integer code with OK/SOMEERROR meaning. The most natural way to carry the exceptional situations should be raise IO exceptions, but here comes the problem: how can I define new Exception codes, instead of raising userError all the time? I think it makes sense for a library to raise specialized exceptions, instead of userErrors. There is such a mechanism? Can someone help? Thanks. --------------------------------------------- Este mensaje lo ha enviado un Alumno de la Universidad de Malaga. http://www.alumnos.uma.es/

1 0

Hypothetical reasoning in type classes
by Ken Shan 16 Nov '03

16 Nov '03

Hello, Has anyone thought about adding hereditary Harrop formulas, in other words hypothetical reasoning and universal quantification, to the instance contexts in the Hsakell type class system? Just today (and not only today) I wanted to write instance definitions like instance (forall a. C a => D a) => E [a] where ... This is analogous to wanting to write a rank-2 dictionary constructor (forall a. C a -> D a) -> E [a] at the term level, but with type classes, this dictionary constructor should be applied automatically, in a type-directed fashion, at compile time. The theory behind such instance contexts doesn't seem so intractable; indeed it looks decidable to my cursory examination. The opreational intuition is that we would like the type checker to generate an eigenvariable "a" and perform hypothetical reasoning. I would also like to quantify universally over type classes; in other words, if "?" is the kind of a type class constraint (aka a dictionary type; perhaps "o" would be a better choice of notation), then I would like to define not just types of kind "*->*->?" (aka type classes) or kind "(*->*)->?" (aka constructor classes), but also types of kind "(*->?)->(*->?)". But that's for another day... Ken -- Edit this signature at http://www.digitas.harvard.edu/cgi-bin/ken/sig "Hi, my name is Kent, and I let people change my .sig on the internet." "Hi, Ken!" "Put midgets back in midget porn!" -- Not authorized by Ken Shan. Supported by the association of midget porn workers, Local 9823.

2 1