- Haskell-Cafe - Haskell.org

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 01 Mar '06

01 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 01 Mar '06

01 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

Picking a shell for runCommand
by Tom Hawkins 28 Feb '06

28 Feb '06

It appears runCommand uses /bin/sh by default, but our environment needs tcsh. Is there any way to set an alternative shell? -Tom

2 1

socket TChan problem
by Stefan Aeschbacher 28 Feb '06

28 Feb '06

Hi I try to write a program that reads from a socket and communicates the result over a TChan and writes it to stdout. Somehow I can't seem to get it right, the result is only printed when I send ETX on the socket. Attached is a sample program that shows the behvaviour. Any hints on where my error is or how I could debug such a problem is appreciated. regards Stefan

2 3

standard poll/select interface
by Bulat Ziganshin 28 Feb '06

28 Feb '06

Hello John, Thursday, February 09, 2006, 3:19:30 AM, you wrote: >> JM> If we had a good standard poll/select interface in System.IO then we >> JM> actually could implement a lot of concurrency as a library with no >> JM> (required) run-time overhead. I'd really like to see such a thing get >> JM> into the standard. Well, mainly it would just be a really useful thing >> JM> to have in general. If others think it is a good idea I can try to come >> JM> up with a suitable API and submit it to the repo. >> >> i have delayed answering to this letter until i announced my Streams >> library. now i can say that such API already exists - in terms of my >> library you need just to write an transformer that intercepts >> vGetBuf/vPutBuf calls and pass them to the select/poll machinery. so >> you can write such transformer just now and every program that uses >> Streams will benefit from its usage. Converting programs that use >> Handles to using Streams should be also an easy task. JM> I was actually asking for something much more modest, which was the JM> routine needed to pass them to the select/poll machinery. but yeah, what JM> you say is one of my expected uses of such a routine. Once a standard IO JM> library settles down, then I can start working on the exact API such a JM> routine would have. but if all will wait while the library settles down, it will never occur :) your work can change design of library, like the my library itself can change the shape of haskell' :) at this moment, i just developed the library which satisfy demands in extending current I/O library by new features, such as Unicode support, high speed, portability to other compilers, binary i/o, i/o for packed strings, and asynchronous i/o using methods other than select(). but i don't implement all these features actually, i just developed infrastructure, in which all these features can be easily added. unlike the System.IO library, you don't need to ask someone to implement new features or make corrections in foreign sources. you just need to develop module what implements this standard Stream interface and then it can be used as easy as transformers from the library itself as i understand this idea, transformer implementing async i/o should intercept vGetBuf/vPutBuf calls for the FDs, start the appropriate async operation, and then switch to another Haskell threads. the I/O manager thread should run select() in cycle and when the request is finished, wake up the appropriate thread. what's all. if you will ever need, this implementation can then be used to extend GHC's System.IO internals with the support for new async i/o managers (as i understand, select() is now supported by GHC, but poll(), kqueue() is not supported?). the only difference that my lib gives an opportunity to test this implementation without modifying GHC I/O internals, what is somewhat simpler. so, interface for async vGetBuf/vPutBuf routines should be the same as for read/write: type FD = Int vGetBuf_async :: FD -> Ptr a -> Int -> IO Int vPutBuf_async :: FD -> Ptr a -> Int -> IO Int i think that implementations for ghc and jhc should be slightly different, though, because of different ways to implement multi-threading. but the I/O manager should be the same - it just receives info about I/O operations to run and returns information about completed ones. ... well, this I/O manager should implement just one operation: performIO :: Request -> IO () type Request = (IOType, FD, Ptr a, Int, Notifier) data IOType = Read | Write | ... type Notifier = Result -> IO () data Result = OK Int | Fail ErrorInfo "performIO" starts new I/O operation. On the completion of this operation, Notifier is called with information about results of execution. so, for the GHC the following should work: vGetBuf_async fd ptr size = do done <- newMVar let notifier = putMVar done () performIO (Read, fd, ptr, size, notifier) takeMVar done for JHC, the body of "vGetBuf_async" may be different if you will find this interface reasonable, at least for the first iteration, i will develop appropriate transformer, so for you remains "only" the implementation of "performIO" >> of course, Streams library is not some standard just now, and moreover >> - it is not compatible with JHC. the greatest problem is what i using >> type classes extensions available in GHC/Hugs what is not in H98 >> standard. so, i'm interested in pushing Haskell' to accept most >> advanced possible extensions in this area and, of course, in actual >> implementing these extensions in the Haskell compilers. alternative >> way to make Streams available to wider range of Haskell compilers is >> to strip support of streams working in monads other that IO. JM> Don't take the absence of a feature in jhc to mean I don't like or want JM> that feature. There are a lot of things I don't have but that I'd JM> definitly want to see in the language simply because I was only shooting JM> for H98 to begin with and was more interested in a lot of the back end JM> stuff. You should figure out the nicest design that uses just the JM> extensions needed for the design you want. it could help us decide what JM> goes into haskell-prime to know what is absolutely needed for good JM> design and what is just nice to have. this simply means that the Streams library cannot be used with JHC, what is bad news, because it is even more rich than GHC's System.IO. jhc had chance to get modern I/O library. but it lost that chance :) >> if you can make select/poll transformer, at least for testing >> purposes, that will be really great. JM> Yeah, I will look into this. the basic select/poll call will have to be JM> pretty low level, but hopefully it will allow interesting higher level JM> constructs based on your streams or an evolution of them. please look. at this moment Sreams library lacks only a few important features, already implemented in GHC's System.IO: sockets, line buffering and async i/o. moreover, i don't have an experience in implementing the async i/o, so foreign help is really necessary addressing these three issues will allow to propose the Streams library as possible System.IO replacement. and as you can see, implementing the "performIO" will allow us to use async i/o for all possible i/o operations, including "get/put_" or vGetContents, for example -- Best regards, Bulat mailto:bulatz@HotPOP.com

8 18

Associated Type Synonyms question
by Niklas Broberg 28 Feb '06

28 Feb '06

Hi, I'm playing around with associated type synonyms (ATS) [1] and the PHRaC interpreter, trying to model existing uses of FDs. I really enjoy working with ATS, but I've come across a situation that I don't quite know how to handle, or indeed if it can be handled at all. The scene is Control.Monad.Writer from mtl, where we can find the following definition (simplified for presentation): class (Monoid w, Monad m) => MonadWriter m w | m -> w where tell :: w -> m () The class MonadWriter has two type parameters, one for the monad itself and the other for that which is written. The Monoid constraint on the output is (I guess) there only as a documentation of sorts, stating that the intention is that the output of subsequent tell's should be combinable using mplus. A simple custom monad that just does output could be written as: data MyWriterM w a = MyWriterM (a, [w]) instance Monad (MyWriterM w) where return x = MyWriterM (x, []) MyWriterM (a, xs) >>= k = let MyWriterM (b, xs') = k a in MyWriterM (b, xs ++ xs') instance MonadWriter (MyWriterM w) w where tell x = MyWriterM ((), [x]) Now, to model this using ATS we would write, ignoring the Monoid constraint, the following class declaration*: class Monad m => MonadWriter m where type Output m tell :: Output m -> m () instance MonadWriter (MyWriterM w) where type Output m = [w] tell x = MyWriterM ((), [x]) This works fine, but the obvious question is then, where to put back the Monoid restriction? This time we want the type Output m to be constrained, so my naive first guess was to write: class (Monad m, Monoid (Output m)) => MonadWriter m where .. but phrac says "illegal context for class MonadWriter: only type variables can be constrained". I can't really think of anywhere else to put the restriction, other than making up an ad hoc class constraint syntax for associated types like class Monad m => MonadWriter m where type (Monoid) Output m ... My first question is already stated: where do I put the Monoid constraint? But since I suspect the answer is "you don't", a number of followup questions spring to mind: - why not? Apart from possibly having to use some ugly syntax for it, are there any fundamental reasons why this should not be allowed? - when looking at the definition of MonadWriter the Monoid constraint is not strictly necessary, and none of the other mtl monads have anything similar. Is it the assumption that this kind of constraint is never really necessary, and thus no support for it is needed for ATS? Hope someone can shed some light on this matter :-) Regards, /Niklas [1] http://www.cse.unsw.edu.au/~chak/papers/CKP05.html * Using Haskell syntax instead of the PHRaC equivalent

11 27

-fno-monomorphism-restriction makes type-inference ambiguous?
by Eike Scholz 27 Feb '06

27 Feb '06

Note: This Question has already been asked on the haskell mailing list. But haskell-cafe seems to be more adequate for for this question. Hi, i have encountered a problem and I don't quite understand the reason why I get the results I get. ghci seems to infer different types for the same expression. Consider that I have disabled the monomorphism restriction in module AGC.lhs (which is attached). and I have a toplevel definition of: > mylength = synAttr listLength loding the module in ghci (6.4) gives (beside some correct warnings): $ Ok, modules loaded: Main. $ *Main> :type synAttr $ synAttr :: (Data b) => ((?stack::[Dyn]) => b -> a) -> Attr a $ *Main> :type listLength $ listLength :: (?stack::[Dyn]) => List -> Float $ *Main> :type (synAttr listLength) $ (synAttr listLength) :: Attr Float $ *Main> :type mylength $ mylength :: (?stack::[Dyn]) => Dyn -> Dyn -> [Dyn] -> Maybe Float $ *Main> let mylength = synAttr listLength $ *Main> :type mylength $ mylength :: Dyn -> Dyn -> [Dyn] -> Maybe Float where > type Attr a = Dyn -> Dyn -> [Dyn]-> Maybe a the problem I have is that inferred types for the toplevel declaration mylength differ from the verbatim equal definition in the Let experssion. for the toplevel it infers: mylength :: (?stack::[Dyn]) => Dyn -> Dyn -> [Dyn] -> Maybe Float for the let-Binding mylength :: Dyn -> Dyn -> [Dyn] -> Maybe Float and this is what I expected. Has anyone an Idea, why this happens? best regards, Eike Scholz PS: Beware of the comments in the attached file. This file is under heavy development. I am dyslexic and don't correct the comments while continuously rewriting code and comments. I hope that the comments are useful anyway. The (+>) (~>) (#>) operators are broken at the moment and don't work the way intended.

2 1