March 2006 - Haskell-Cafe

Comparing programs
by Harry Chesley 06 Mar '06

06 Mar '06

This is more of an algorithm question than a language question, but any insights would be much appreciated. The problem is to input a series of programs and find previous occurrences of the same algorithm. The programs consist of a set of input parameters (a, b, c, ...), and a set of side-effect-free functions (f, g, h, ...). Since the functions are side-effect-free, they can be reordered without changing the algorithm ("f(a), g(b)" is the same as "g(b), f(a)"). Subsequent calls of the same function with the same parameters have no effect ("f(a), f(a)" is the same as "f(a)"); in fact, you can assume duplicates have been removed in earlier processing. But here's the thing that makes it hard (at least for me): two programs are considered the same if they can be made to match by rearranging the order of the input parameters. I.e., "f(a), g(b)" is the same as "f(b), g(a)". Although parameters can be reordered, they cannot be substituted ("f(a), g(b)" is _not_ the same as "f(a), g(a)"). Example: "f(a), g(b), h(a, b)" is the same as "f(b), g(a), h(b, a)" but _not_ the same as "f(a), g(b), h(b, a)". I need a way to compare the input programs, and preferably to order them. In Haskell terms, given the programs are represented by a type Prog, I want Prog to be a member of class Ord, letting me use tools like Data.Map to look up information about previous instances. I can do a brute-force compare by trying all the parameter permutations, but that only gives me Eq, not Ord, and seems terribly inelegant as well.

4 3

Credit Card Authorization code
by S. Alexander Jacobson 06 Mar '06

06 Mar '06

I am looking for Haskell code that does credit card authorization? e.g. paypal website pro does not supply a Haskell lib. Does anyone know where to find something like this? -ALex- ______________________________________________________________ S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com

2 1

Hacking Hawk
by szefirov＠ot.ru 06 Mar '06

06 Mar '06

Hawk didn't updated from GHC v4.04. It does contain dependencies on functions that are present in my current (6.04) GHC distribution, but they are not documented. Those functions and constructors are (just a error log from ghc): --------------------------- AQ.lhs:17:16: Not in scope: type constructor or class `STArray' AQ.lhs:82:14: Not in scope: `newSTArray' AQ.lhs:92:21: Not in scope: `writeSTArray' AQ.lhs:258:27: Not in scope: `readSTArray' AQ.lhs:262:27: Not in scope: `writeSTArray' --------------------------- They are in GHC.Arr module now. I found that googling for their name. They also changed their types so that they are not compatible with Control.Monad.ST (previous versions were compatible with LazyST). What does they do? Is it possible to rewrite them for current version of ghc?

3 2

Haskell documentation and GADTs
by Jim Apple 06 Mar '06

06 Mar '06

I'm having trouble generating automatic documentation in a module with GADTs. Haddock gives a parse error, and http://www.cse.ogi.edu/~hallgren/Programatica/tools/features.html seems to indicate that Programmatica will as well. Any ideas? Jim

1 0

afrp code base
by Instinctive 04 Mar '06

04 Mar '06

I've been coming up to speed on afrp, and I see the code base is almost two years old. Is this the state of the art? Thanks.

3 2

trying to understand runProcess handles
by Matthias Fischmann 03 Mar '06

03 Mar '06

hi there, I am running some unix command. I just realized there is runInteractiveProcess in System.Process, so my problem is solved in practice: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ showPlot :: String -> IO (Handle, Handle, Handle, ProcessHandle) showPlot file = runInteractiveProcess executable arguments wd env where executable = "/usr/bin/gnuplot" arguments = ["-geometry", "-19+3", file, "-"] wd = Nothing env = Nothing ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ But first I tried to create the handles myself with createPipe from System.Posix.IO, and I failed for a reasons that I have no clue how to learn to understand. This is what the code looked like: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ showPlot :: String -> IO (ProcessHandle, Handle, Handle, Handle) showPlot file = do (stdinR, stdinW) <- createPipeHandles (stdoutR, stdoutW) <- createPipeHandles (stderrR, stderrW) <- createPipeHandles h <- runProcess executable arguments wd env (Just stdinR) (Just stdoutW) (Just stderr W) return (h, stdinW, stdoutR, stderrR) where executable = "/usr/bin/gnuplot" arguments = ["-geometry", "-19+3", file, "-"] wd = Nothing env = Nothing createPipeHandles :: IO (Handle, Handle) createPipeHandles = do (fR, fW) <- createPipe hR <- fdToHandle fR hW <- fdToHandle fW return (hR, hW) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ The problem is that gnuplot terminates right away after it tries to read from stdin (I can see the shadow of a window appear and vanish immediately). I tried setFdOption, with no effect. Is this because the handles passed to runProcess are closed in the parent process, and therefore the pipe is teared down and useless? I don't think so: If I run 'find /' instead of gnuplot, the process happily starts and I can hGetLine from stdout. If you have any clue I'd love to learn. Anyway, as I said, it's really better to simply use runInteractiveProcess in this simple case. thanks, Matthias

2 3

rounding errors with real numbers.
by Matthias Fischmann 03 Mar '06

03 Mar '06

hi, I think this is the well-known issue of using real numbers in decimal representation on a machine that thinks binary, but I don't know what to do with it, and some of you maybe do. I want to shift+stretch a list of doubles into a given interval. example: | x1 = [2, 3, 4, 5, 10] | y1 = normInterval x1 0 1 | => y1 = [0.0,0.125,0.25,0.375,1.0] The function that does this looks something like this: | normInterval :: [Double] -> Double -> Double -> [Double] | normInterval ps lower upper = map (\ x -> (x - oldLower) * stretch + lower) ps | where | oldLower = head ps | oldUpper = last ps | stretch = (upper - lower) / (oldUpper - oldLower) However, with bigger numbers I get rounding errors: | x2 = [0.0,1.9569471624266144e-3,5.870841487279843e-3,1.5655577299412915e-2,3.913894324853229e-2,9.393346379647749e-2,0.2191780821917808,0.5009784735812133,1.1272015655577299,2.504892367906066] | y2 = normInterval x2 0 1 | => y2 = [0.0,7.8125e-4,2.3437500000000003e-3,6.25e-3,1.5625000000000003e-2,3.7500000000000006e-2,8.750000000000001e-2,0.2,0.45000000000000007,0.9999999999999999] The solution that pops to my mind is very simple: | normInterval :: [Double] -> Double -> Double -> [Double] | normInterval ps lower upper = repair (map (\ x -> (x - oldLower) * stretch + lower) ps) | where | oldLower = head ps | oldUpper = last ps | stretch = (upper - lower) / (oldUpper - oldLower) | | -- fix rounding error: | repair [i] = [upper] | repair (h:t) = h : repair t It works, but it's ugly. Is there a better way to do this? Thanks, Matthias

7 14

Re: Template haskell instance checking
by heatsink 02 Mar '06

02 Mar '06

>>Is there a way, in template haskell, to find out what instance >>declarations >>exist? >Not at the moment, I'm afraid, but it's the kind of question that TH >ought to be able to answer. I could offer guidance if someone wanted to >implement it. I have a concern about how computed class memberships would work. Class membership is global, so creating a class instance is a globally visible side effect of TH code. Once you add the ability for TH code to inspect instances, the side effects mean that the order in which different splices get executed affects the compiler output. This is probably a bad thing. I'm not sure how it could be designed to work nicely; the only approach I can think of at the moment is to give splice evaluation a dataflow execution semantics that causes splices to execute and possibly reexecute at the "appropriate" times. I'd like to hear if anyone else has ideas on how to solve this problem. .....tian: I think that's a good point in general about conditional code generation. I wasn't thinking about conditional generation based on compile-time settings, but rather reusable TH library functions that inspect the class memberships of their arguments. Of course, this can be used for good or evil :) --heatsink

1 0

Help with Type Class
by Alson Kemp 02 Mar '06

02 Mar '06

Although the discussion about Array refactoring died down quickly on the Haskell' mailing list, I've been noodling on refactoring the various Collections in Haskell. In doing so, I've bumped into a problem with type classes that I can't resolve. The issue is as follows: I'm designing a Collections class heirarchy that is a blend between that of Java and of Haskell. The problem is that, whereas in OOP it is easy to do so, Haskell class mechanism seems to make it difficult to add *new* member variable to subclasses. Simple goal: create a top-level Collection with an *indexed* Array subclass (and various other subclasses). The problem I'm running into is Collection has no need of an "index" variable and I can't seem to figure out how to add an "index" to Array when subclassing from Collection Mock up: -- class CollectionClass c e where -- every Collection supports toList... toList :: c e -> [e] class (CollectionClass a e)=> ArrayClass a e where ... data Array i e = Array i i instance CollectionClass Array e where -- Since Array is a Collection -- toList :: c e -> [e] -- but with an Array the type would be -- toList :: a i e -> [e] toList = ... -- I think that the problem goes away if: class CollectionClass c x e where ... with "x" used an index for Array or a key for Map or () for Set, but it doesn't seem clean to scatter member variables in the parent class in case the subclass requires them... Another possible solution that I couldn't get to work would be to use (Array i) as the type for "c" in "Collection c": instance CollectionClass (Array i) e where toList = ... -- (Array i) e -> [e] ? This seems clean because it says the Collection holds "e"s and is organized by an (Array i). Similarly, Set would be a Collection of "e"s organized by Set and Map would be a Collection of "e"s organized by (Map k). Undoubtedly, I've missspoken some crucial aspect of the type/kind/class/instance magical incantation. Help! - Alson

3 4

Template haskell instance checking
by heatsink 02 Mar '06

02 Mar '06

Is there a way, in template haskell, to find out what instance declarations exist? I'm not trying to accomplish anything specific right now, but I can see two potential uses for this. One is to emit compile-time error messages from TH code which would be more informative than the typechecker's output. The other is to produce TH functions that conditionally generate code depending on the instances satisfied by their arguments. I offer the following as a motivational example. Suppose you want to write an extensible library to handle files for, e.g., image data: class FileFormat a where formatName :: a -> String read :: Handle -> IO a write :: Handle -> a -> IO () instance FileFormat TheStandardFormat where .... class (FileFormat a, FileFormat b) => Convert a b where convert :: a -> b Now it would be nice to generate instances of (Convert a TheStandardFormat, Convert TheStandardFormat b) => Convert a b _except_ where there is an explicit definition for (Convert a b). AFAIK, there's no way to do this at present, but it seems like something that could be computed in TH. --heatsink

2 1