- Haskell-Cafe - Haskell.org

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

04 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 03 Mar '06

03 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

RE: [Haskell-cafe] Template haskell instance checking
by Simon Peyton-Jones 02 Mar '06

02 Mar '06

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. Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of | heatsink | Sent: 02 March 2006 00:55 | To: haskell-cafe(a)haskell.org | Subject: [Haskell-cafe] Template haskell instance checking | | 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 | | | _______________________________________________ | Haskell-Cafe mailing list | Haskell-Cafe(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

module for probability distributions
by Matthias Fischmann 02 Mar '06

02 Mar '06

hei again, (-: I wrote a module for sampling arbitrary probability distribution, so far including normal (gaussian) and uniform. http://www.wiwi.hu-berlin.de/~fis/code/ For those who need something like this: feel free to take it, it's BSD. For those who feel like growing their karma: - There are a few questions in the code (marked with 'XXX'). - There are probably far better way to do this. I am eager to learn. - There is probably a better implementation out there already. Please point me to it. cheers, Matthias

3 2

enforcing strictness on arbitrary subexpressions
by Matthias Fischmann 02 Mar '06

02 Mar '06

hei, I want to force evaluation on an arbitrary expression. What I have found is only strict datatypes (the '!' thing), but not a strictness idiom for arbitrary subexpressions. (I want this for debugging mostly, so if there is a better way to unsafePerformIO something in one piece I would be happy with that, too.) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ veryLongString = "..." data StrictThingy = StrictThingy ! String main :: IO () main = do hPutStr stdout veryLongString -- lazy veryLongString `seq` hPutStr stdout veryLongString -- still lazy? (StrictThingy veryLongString) `seq` hPutStr stdout veryLongString -- strict (or at least i hope it is) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Problem with the last line is that it doesn't work for arbitrary types, and it's kind of ugly. What I would like to have is something like: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ hPutStr stdout ! veryLongString ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ but I guess it's not that easy? Sorry for asking without consulting the list archives, but I promise I'll add it to the faq in the wiki once i understood. (-: I am using ghci and ghc, latest ubuntu package, but I am happy to switch to new versions. thanks, matthias

3 3

Code snippet, a `trace' with line and column numbers
by dons＠cse.unsw.edu.au 01 Mar '06

01 Mar '06

Suggested by a question from sethk on #haskell irc channel. Solves an FAQ where people have often resorted to cpp or m4: a `trace' that prints line numbers. > module Location (trace, assert) where > > import qualified Control.Exception as C (catch) > import System.IO.Unsafe (unsafePerformIO) > import GHC.Base (assert) > import System.IO > > -- An identity function that also prints the current line and column number > trace :: (Bool -> IO () -> IO ()) -> a -> a > trace assrt f = (unsafePerformIO $ C.catch (assrt False $ return ()) printIt) `seq` f > where > printIt e = let (x,_) = break (== ' ') $ show e > in hPutStrLn stderr (x ++ " trace") for example: > import Location > > main = do > let x = trace assert (1+2) > > putStrLn . show $ x Generates: $ ./a.out M.hs:4:18-23: trace 3 This continues a theme I've noticed: catching internal exceptions can yield some interesting results, i.e. with undefined, missing class methods, and here, assertion failures. Hope this little thing is useful. Cheers, Don

1 0

My piece of an IRC bot
by ihope 01 Mar '06

01 Mar '06

Today I started on a simple IRC bot framework thingy. I decided to post the source code here so people can look at it and tell me what the heck I did wrong :-P > module IRC where > > import Control.Monad.State > import System.IO > import Network > > {----------------------}{------------------------------------------------------} > > data IRCMessage = IRCMessage (Maybe String) String [String] > > type IRCBot a = IRCMessage -> State a [IRCMessage] > type IRCConnection a = IRCBot a -> IO () > > ircConnect :: String -> Integer -> a -> IRCConnection a > > ircConnect server port > state bot = withSocketsDo (do > connection <- connectTo server (PortNumber (fromInteger port)) > ircLoop connection state bot) > > ircLoop connection state > bot = do > eof <- hIsEOF connection > if eof then hWaitForInput connection 500 >> return () else do > message <- hGetLine connection > hPutStr connection (fst (runState (bot (ircParseMessage message)) state) >>= > decodeMessage) > ircLoop connection (snd (runState (bot (ircParseMessage message)) state)) > bot > > -- Oh noes. Let's hope we'll never, ever have to read that ;-) > > {-End I/O capable code-}{------------------------------------------------------} > > ircParseMessage x = let rx = filter (/='\r') x > (p:u:us) = words rx in > if (head p) == ':' then IRCMessage (Just p) u > (ircParseParams us) > else IRCMessage Nothing p (ircParseParams (u:us)) > > ircParseParams (x:xs) = if head x == ':' then [unwords (x:xs)] > else x : ircParseParams xs > > decodeMessage (IRCMessage > Nothing command params)= (command ++ ' ' : unwords (init params) ++ ' ' : > (':' : last params)) > > decodeMessage > (IRCMessage (Just > prefix) command params)= ((':' : prefix) ++ ' ' : command ++ ' ' : unwords > (init params) ++ (':' : last params)) > > {-Thus ends the IRCbot-}{------------------------------------------------------} The very simple bot I've been trying to run with it: > module Main where > > import IRC > import Control.Monad.State > > {----------------------}{------------------------------------------------------} > > main = ircConnect "brown.freenode.net" 6667 False bot > > bot _ = State (\x -> if x then ([],True) else ( > [IRCMessage Nothing "NICK" ["EagleBot"], > IRCMessage Nothing "USER" ["EagleBot", "Null", > "Null", "EagleBot"], > IRCMessage Nothing "PRIVMSG" ["NickServ", > "IDENTIFY censored"], > IRCMessage Nothing "JOIN" ["#esoteric"]],True))

1 0