- Haskell-Cafe - Haskell.org

Yet another top-level state proposal
by Judah Jacobson 29 May '07

29 May '07

Hi all, Given the recent discussion about adding top-level mutable state to Haskell, I thought it might be a good time to throw my own proposal into the ring. If enough people think it's worth considering, I can add it to the wiki page. (http://www.haskell.org/haskellwiki/Top_level_mutable_state) In contrast to recent proposals, this one requires no extra syntax or use of unsafe functions by the programmer. Any nonstandard "magic" that might occur is kept within the compiler internals. Furthermore, top-level initializations are only executed when needed; merely importing a module does not cause any additional actions to be run at startup. The core idea, similar to that of "type-based execution contexts" on the above wiki page, is to associate each top-level action with its own type. For example, the current way to declare a source for unique integers is: ------------------------------------------------ {-# NOINLINE uniqueRef #-} uniqueRef :: IORef Integer uniqueRef = unsafePerformIO $ newIORef 0 uniqueInt :: IO Integer uniqueInt = do n <- readIORef uniqueRef writeIORef uniqueRef (n+1) return n ------------------------------------------------ Under this proposal, we would write instead: ------------------------------------------------ newtype UniqueRef = UniqueRef (IORef Integer) deriving OnceIO instance OnceInit UniqueRef where onceInit = liftM UniqueRef (newIORef 0) uniqueInt :: IO Integer uniqueInt = do UniqueRef uniqueRef <- runOnceIO n <- readIORef uniqueRef writeIORef uniqueRef (n+1) return n ------------------------------------------------ The above code uses two classes: class OnceInit a where onceInit :: IO a class OnceInit a => OnceIO a where runOnceIO :: IO a The OnceInit class lets the programmer to specify how a type is initialized; above, it just allocates a new IORef, but we could also read a configuration file or parse command-line arguments, for example. In contrast, instances of the OnceIO class are not written by the programmer; instead, they are generated automatically by a "deriving OnceIO" clause. Each type for which OnceIO is derived will have a special top-level action associated with it, which is accessed through the runOnceIO function. Its semantics are: - The first time that "runOnceIO" is called, it runs the corresponding "onceInit" action and caches and returns the result. - Every subsequent time that "runOnceIO" is called, it returns the cached result. This behavior is safe precisely because runOnceIO is an IO action. Even though one can't guarantee when in the program an initialization will occur, when the initialization does happen it will be sequenced among other IO actions. To illustrate this behavior, here are a couple sample implementations in plain Haskell. These do use unsafePerformIO, but in practice any such details would be hidden in the instance derived by the compiler (along with any related NOINLINE/NOCSE pragmas): instance Once UniqueRef where runOnceIO = return $! unsafePerformIO onceInit or (less efficient, but multithreaded safe): instance Once UniqueRef where runOnceIO = modifyMVar onceUniqueRef $ \mx -> case mx of Just x -> return (Just x, x) Nothing -> do {x <- onceInit; return (Just x, x)} onceUniqueRef = unsafePerformIO $ newMVar Nothing Finally, note that the deriving clause can easily check whether the type in question is monomorphic (as is necessary for type-safety), since it already has access to the type definition. Anyway, that's the gist of my proposal; I hope I've explained it well, but please let let me know if you have questions, suggestions or criticisms. Best, -Judah

6 6

Re: [Haskell-cafe] The C Equiv of != in Haskell
by PR Stanley 29 May '07

29 May '07

>Hi > >>What is the C equivalent of the inequality operator in Haskell? > >/= > >You can answer these sorts of questions yourself using Hoogle: And what makes you think I haven't tried Google already? Unlike you I only write to the list when I have a legitimate reason to do so.

9 12

Re: [Haskell-cafe] The C Equiv of != in Haskell
by PR Stanley 29 May '07

29 May '07

Thank you Neil, again I'm sorry for getting the wrong end of the stick. Cheers Paul At 02:50 29/05/2007, you wrote: >Hi Paul > >Sorry if you interpreted my answer as a symbol, I never use smilies so >didn't even consider that people may see it in another light! > >Thanks > >Neil > > >On 5/29/07, PR Stanley <prstanley(a)ntlworld.com> wrote: >> >> > > >Hi >> > > > >> > > >>What is the C equivalent of the inequality operator in Haskell? >> > > > >> > > >/= >> > > > >> > > >You can answer these sorts of questions yourself using Hoogle: >> > > >> > > And what makes you think I haven't tried Google already? >> > > Unlike you I only write to the list when I have a legitimate >> reason to do >> > > so. >> > >> >Just in case there was some sort of miscommunication, the actual answer to >> >your question is (/=) :: a -> a -> Bool, as Neil said. >> > >> >The /= wasn't some sort of frowny, quit-wasting-my-time emoticon. >> >_______________________________________________ >>Thank you, Dan. >>Regards >>Paul >> >>_______________________________________________ >>Haskell-Cafe mailing list >>Haskell-Cafe(a)haskell.org >>http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

Re: [Haskell-cafe] The C Equiv of != in Haskell (Apologies)
by PR Stanley 29 May '07

29 May '07

>Hi > >> >You can answer these sorts of questions yourself using Hoogle: >>And what makes you think I haven't tried Google already? > >Hoogle, starting with 'H'. Follow the link I gave you, which is a >search engine for Haskell functions, by type and name. If you search >for "a -> a -> Bool" (a likely type that the != would have) then >Hoogle gives you an answer. > >>Unlike you I only write to the list when I have a legitimate reason to do so. > >I am not suggesting you have no legitimate reason, just trying to help >you find the information you need quicker in future. I was in no way >trying to suggest you shouldn't have posted - its a fair question >given its a different choice to most other languages. > >Thanks > >Neil Thank you,Neil. I apologise for my sharp response. It's been a long day. However, I don't think these other individuals had any business poking their hooters into this. All the best, Paul

2 1

Re: [Haskell-cafe] The C Equiv of != in Haskell
by PR Stanley 29 May '07

29 May '07

At 03:02 29/05/2007, you wrote: >On 5/29/07, PR Stanley <prstanley(a)ntlworld.com> wrote: >>What is this, the Haskell Cafe Gang? > >Maybe. Moreover this list is not a prepaid service in which you can >unpolitely _demand_ answers. > >You got your question answered still complain ... I don't get it. Yes, the question has been answered but you still feel the need to keep the thread alive, hmm, you're right, it is very strange behaviour indeed.

1 0

The C Equiv of != in Haskell
by PR Stanley 29 May '07

29 May '07

Hi What is the C equivalent of the inequality operator in Haskell? Thanks Paul

2 1

Bug in GADT Implementation?
by Dominic Steinitz 29 May '07

29 May '07

I would expect foo r@(Range BITSTRING _ _) x = [] to give an error but it doesn't. Writing t = Range BITSTRING gives one so why not the pattern match? Dom. data BitString = BitString [Bool] deriving Show data ConstrainedType :: * -> * where INTEGER :: ConstrainedType Int BITSTRING :: ConstrainedType BitString Seq :: ConstrainedType a -> ConstrainedType b -> ConstrainedType (a,b) Range :: Ord a => ConstrainedType a -> a -> a -> ConstrainedType a foo :: ConstrainedType a -> a -> [Int] foo BITSTRING (BitString x) = map fromEnum x foo INTEGER x = [x] foo r@(Range INTEGER _ _) x = [upperInt r,x] foo r@(Range BITSTRING _ _) x = [] r1 = Range INTEGER 20 40 r2 = Range r1 25 45 upperInt :: ConstrainedType Int -> Int upperInt INTEGER = 256 upperInt (Range t l u) = min u (upperInt t)

6 7

Curiose types
by Andrew Coppin 28 May '07

28 May '07

As I lay in bed last night, a curios fact occurred to me. (Yes, I don't get out very much...) Consider the map function: map :: (a -> b) -> [a] -> [b] There are two ways you can think about this function. First, you can see it as meaning map :: (a -> b) -> ([a] -> [b]) Which is beautifully symmetric. Alternatively, you can think about how you actually use it: map :: ((a -> b) -> [a]) -> [b] Now this got me thinking: is (->) associative? x_x Well now, let's consider a general 3-argument function: foo :: a -> b -> c -> d According to the rules, this is of course equivilent to foo :: a -> (b -> (c -> d)) If you understand what currying is and how it works, this makes perfect sense. Now let's bracket that the other way: foo :: ((a -> b) -> c) -> d Well, while that type *does* make sense, it's clearly a completely *different* type! So, clearly, (->) is not associative. Now I'm left wondering why you can bracket the type for map in two different ways, but not in general. Hmm...

8 9

Re: [Haskell-cafe] Language extensions
by Andrew Coppin 28 May '07

28 May '07

Chaddaï Fouché wrote: > 2007/5/28, Andrew Coppin <andrewcoppin(a)btinternet.com>: >> Then again, later on in the very same book there's a chapter entitled >> "Fun with Phantom Types", which made precisely no sense at all... >> > > You seem to think you're extremely clever since if something doesn't > make sense to you it _obviously_ doesn't make sense at all... Well it > at least made sense for the authors of the article, and lots of person > who read it. Surely it makes sense to someone. (But then, there are people to whom number theory makes sense.) I didn't mean to imply that it is *impossible* to comprehend the article, only that it's very greatly beyond my capabilities. I like to think I'm an intelligent, but... maybe I'm just kidding myself...

2 1

Random ramble
by Andrew Coppin 28 May '07

28 May '07

[You may want to just hit delete now? ;-) ] I don't know where everybody else is, but where I live, we have various science programs on TV from time to time. (Horizon being a fairly regular one.) They grab a bunch of eggheads, and try to get them to explain (in soundbites) some topic or other. Sometimes it's string theory, or quantum dynamics, or chaos theory, or something like that. (And sometimes it's economics - and then I change channel.) Usually the producers go to great lengths to make the subject seem "interesting" - that is, try to be as over-dramatic as possible. Often accompanied with copious computer graphics, which mainly just look pretty. Anyway, I was sitting here thinking to myself "hey, what if they got a bunch of people to talk about Haskell?" (That's *one* way to get publicity...!) I don't know how many of you are as neurotically familiar with The Matrix as I am, but... I found myself visualising that scene from about mid-way through the film. Morpheus: "This may feel... a little weird." [6 inch metal plug injected into the back of Neo's skull] Neo: "AAAAAAAAAAARRGH!!" [They turn on the computer.] [Neo finds himself floating in a sea of lambda functions, higher-kinded class instances and parametric polymorphism.] ...and then I find myself thinking of http://xkcd.com/c224.html Erm... OK, I'll go sit in the corner and be quiet now.

1 0

GADT and typeclasses [was: Language extensions]
by oleg＠pobox.com 28 May '07

28 May '07

Philippa Cowderoy wrote: > For example, GADTs let you implement monads as interpreters by defining a > datatype representing the abstract syntax tree that describes a > computation - you can't get this to type without at a minimum existential > types and for many monad operations you need the full power of GADTs to > declare a corresponding constructor. I'm yet to see the example of that need. I have seen the examples that the need for GADT was _claimed_ -- but then it turns out the example is implementable without GADT after all. Here are a few such examples: implementing State monad in a free term algebra Initial (term) algebra for a state monad http://www.haskell.org/pipermail/haskell-cafe/2005-January/008241.html Implementing an interpreter in HOAS with fix Even higher-order abstract syntax: typeclasses vs GADT http://www.haskell.org/pipermail/haskell/2007-January/019012.html

3 2

Parsec question
by Andrew Coppin 27 May '07

27 May '07

Greetings. I'd like to write a parser that takes some Haskell source code and seperates it into two piles - comments, and everything else. I have a parser that recognises single-line comments, and another that recognises multi-line comments. What I'd like to do is make a big parser that returns [Either String String], which all the comments in one side and all the rest in the other side. But I can't figure out how to construct such a parser... Any hints?

2 2

Broadcast signals between threads
by Joachim Breitner 27 May '07

27 May '07

[Arg. Just lost the mail and have to re-type it. Sorry if I’m not as verbose as I should be]. Hi, I’m writing a TCP server app ATM. It has one thread per client. Some of the clients want to be notified if the internal state changes, while others are happily chatting with the server, possible modifying the internal state. What I need now is a way for the chatting thread to signal “anyone interested” that the state has changed. The semantics should be roughly these: * All listening threads run some wait-for-signal command that blocks until the signal is sent. * The state changing thread notifies the others by some signal-sending-command, which should not block. * It does not matter if no one is listening, or if threads miss signals because they are doing something else for the moment, or if several sent signals are handled only once. Here is my implementation so far: newtype MSignal a = MS (MVar a) newMSignal = MS `liftM` newEmptyMVar sendMSignal (MS mv) v = do forkIO $ takeMVar mv >> return () -- Cleanup afterwards putMVar mv v receiveMSignal (MS mv) = readMVar mv It builds on MVar’s promise that takeMVar and readMVar commands are handled FIFO, so by spawning a takeMVar thread, the sender ensures that exactly after all currently waiting threads are served the value is taken out of the MVar and everything is done. readMVar will both take the value and put it back, so that the next waiting thread (or the sending thread’s cleanup thread) can take the value. Do you think this is a sensible way to do it? Any pitfalls that I have overlooked? Might this be useful enough to be included in some mainstream library? Greetings, Joachim -- Joachim Breitner e-Mail: mail(a)joachim-breitner.de Homepage: http://www.joachim-breitner.de ICQ#: 74513189

3 5

FFI and multi-threading
by Maurício 27 May '07

27 May '07

Do you guys know of a good example of Haskell calling functions to a thread-safe library (like an existing interface to a real library)? I have a function to which I need to alocate memory for each thread calling it, but I don't know how to do that. Thanks, Maurício

2 1

Newbie list question
by junkywunky 27 May '07

27 May '07

type Person = (NI, Age, Balance) type Bank = [Person] credit :: Bank -> [Person] credit [(a,b,c)] = [(a,b,c)] This code works when I type in: credit [(1,2,3)] but doesn't work when I type in: credit [(1,2,3),(4,5,6)] Any help? Thanks in advance. -- View this message in context: http://www.nabble.com/Newbie-list-question-tf3823011.html#a10823175 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

4 6

problem reading /proc/interrupts with ByteString
by Leandro Lisboa Penz 27 May '07

27 May '07

Hi I'm having some problems using ByteString.Char8.readFile to read "/proc/interrupts". I reads nothing. I guess maybe that's because the file is sort of special, but I could read it by opening and using ByteString.Char8.hGetContents. The part of interest is: findInterrupts :: B.ByteString -> Int findInterrupts str = findI where findI = read $ B.unpack $ getNums $ skipSpaces $ skip1 from1 = case B.findSubstring (B.pack "1:") str of Nothing -> error $ "Not found in [" ++ B.unpack str ++ "]" Just a -> a skip1 = B.drop from1 str skipSpaces = B.dropWhile (\c -> c == ' ') getNums = B.takeWhile (\c -> c `elem` "1234567890") getNumInterrupts :: IO Int getNumInterrupts = do h <- openFile "/proc/interrupts" ReadMode c <- B.hGetContents h hClose h -- c <- B.readFile "/proc/interrupts" -- With readFile the contents are emtpy -- B.putStrLn c return $ findInterrupts c Whole code can be found at http://hpaste.org/63 Thanks in advance Leandro Penz

2 1

CYK-style parsing and laziness
by Steffen Mazanek 27 May '07

27 May '07

Hello, I have two questions regarding a Cocke, Younger, Kasami parser. Consider this program: type NT = Char -- Nonterminal type T = Char -- Terminal -- a Chomsky production has either two nonterminals or one terminal on its right-hand side type ChomskyProd = (NT, Either T (NT, NT)) -- a grammar consists of a startsymbol, nonterminal symbols, terminal symbols and productions type Grammar = (NT, [NT], [T], [ChomskyProd]) parse::Grammar->[T]->Bool parse (s, nts, ts, prods) w = s `elem` gs n 1 where n = length w table = [[gs i j|j<-[1..n-i+1]]|i<-[1..n]] gs 1 j = [nt|p<-prods,termProd p, let (nt, Left t)=p, w!!(j-1)==t] gs i j = [nt|k<-[1..i-1],p<-prods, not (termProd p), let (nt, Right (a, b))=p, a `elem` table!!(k-1)!!(j-1), b `elem` table!!(i-k-1)!!(j+k-1)] The sets gs i j contain all nonterminal symbols from which the substring of w starting at index j of length i can be derived. Please have a look at the last line of the algorithm. In my first attempt I just referred to gs k j and gs (i-k) (j+k) what looks a lot more intuitive. However I noted that this way the sets gs i j are evaluated multiple times. Is there a better and more readable way to prevent multiple evaluation of these sets? The second question regards lazy evaluation. Consider the stupid grammar S->S S S->A A A->a that generates a^(2n). The performance of the algorithm drops very fast even for small n, probably because the gs i j are getting very large. Is there a trick to get lazy evaluation into play here? It is sufficient to find only one occurence of the start symbol in gs n 1. Best regards, Steffen

3 5

Haskell Library on CNN
by Yitzchak Gale 27 May '07

27 May '07

Border conditions in the Haskell Library have finally made the mainstream media: http://www.cnn.com/2007/US/05/26/border.quirk.ap/index.html -Yitz

1 0

LUGRadio Live anyone?
by Magnus Therning 27 May '07

27 May '07

Just wondering if anyone else who frequents this list is planning on going to Wolverhampton for LRL in July? /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus(a)therning.org Jabber: magnus.therning(a)gmail.com http://therning.org/magnus Software is not manufactured, it is something you write and publish. Keep Europe free from software patents, we do not want censorship by patent law on written works. Failure is not an option. It comes bundled with the software.

1 0

Cannot compile Network.CGI programs
by Adrian Neumann 26 May '07

26 May '07

-----BEGIN PGP SIGNED MESSAGE----- Hash: RIPEMD160 Hi, I installed the Network.CGI package and tried to compile the Hello World example on my Ubuntu machine. >ghc cgi.hs -o cgi gives me > cgi.o: In function `r1hk_info': > (.text+0x56): undefined reference to `mtlzm1zi0_ControlziMonadziTrans_zdf1_closure' > cgi.o: In function `r1hm_info': > (.text+0xb6): undefined reference to `cgizm2006zi9zi6_NetworkziCGIziMonad_zdf4_closure' > cgi.o: In function `r1ho_info': > (.text+0x11a): undefined reference to `cgizm2006zi9zi6_NetworkziCGI_runCGI_closure' > cgi.o: In function `r1ho_info': > (.text+0x121): undefined reference to `mtlzm1zi0_ControlziMonadziTrans_zdf1_closure' > cgi.o: In function `r1hq_info': > (.text+0x17e): undefined reference to `cgizm2006zi9zi6_NetworkziCGI_output_closure' > cgi.o: In function `s1hE_info': > (.text+0x2aa): undefined reference to `cgizm2006zi9zi6_NetworkziCGI_handleErrors_closure' > cgi.o: In function `r1hk_srt': > (.rodata+0x0): undefined reference to `mtlzm1zi0_ControlziMonadziTrans_zdf1_closure' > cgi.o: In function `r1hm_srt': > (.rodata+0x4): undefined reference to `cgizm2006zi9zi6_NetworkziCGIziMonad_zdf4_closure' > cgi.o: In function `r1ho_srt': > (.rodata+0xc): undefined reference to `cgizm2006zi9zi6_NetworkziCGI_runCGI_closure' > cgi.o: In function `r1ho_srt': > (.rodata+0x10): undefined reference to `mtlzm1zi0_ControlziMonadziTrans_zdf1_closure' > cgi.o: In function `r1hq_srt': > (.rodata+0x14): undefined reference to `cgizm2006zi9zi6_NetworkziCGI_output_closure' > cgi.o: In function `s1hE_srt': > (.rodata+0x38): undefined reference to `cgizm2006zi9zi6_NetworkziCGI_handleErrors_closure' > collect2: ld gab 1 als Ende-Status zurück However runghc cgi.hs produces a Hello World > Content-type: text/html; charset=ISO-8859-1 > > Hello World! Why is that so? What can I do to compile CGI-programs? (GHC 6.6, libghc6-cgi-dev 2006.9.6-3) -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.7 (MingW32) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org iD8DBQFGV+k211V8mqIQMRsRA62mAKCW0lp+zeniR+3Mi12+9dzRFMZm6QCaArpd R67KMtScgzFFDV0+GDbH75A= =Wuax -----END PGP SIGNATURE-----

2 1

instance Monad AppF - Faster than the list monad?
by Robin Green 26 May '07

26 May '07

The following Haskell 98 module implements a generalisation of Prelude.ShowS for any type. Should be pretty easy to incorporate this into code which currently uses the list monad non-trivially, and get better performance - but can this be right? Surely someone would have published this before if that was true? I haven't actually done any performance tests. Anyway, with this module you end up using function composition instead of list concatenation - except when converting from a list. module Data.List.AppF where import Control.Monad (MonadPlus (mplus, mzero), msum) -- Generalisation of ShowS newtype AppF a = AppF { unAppF :: [a] -> [a] } instance Monad AppF where (>>=) = (msum .) . flip map . appFToList return = AppF . (:) instance MonadPlus AppF where mzero = AppF id mplus x y = AppF $ unAppF x . unAppF y -- Use this to convert Maybe a into AppF a, or indeed any other -- MonadPlus instance. maybeToMonadPlus :: MonadPlus m => Maybe a -> m a maybeToMonadPlus = maybe mzero return listToAppF :: [a] -> AppF a listToAppF = AppF . (++) appFToList :: AppF a -> [a] appFToList = ($ []) . unAppF

2 1

Why this exception occurs ?
by L.Guo 26 May '07

26 May '07

Hi. In GHCi ver 6.6, why this happens ? Prelude Data.ByteString> Data.ByteString.pack $! Prelude.map (`rem` 256) $ [0..511] "*** Exception: divide by zero -------------- L.Guo 2007-05-25

6 10

The danger of Monad ((->) r)
by Tomasz Zielonka 26 May '07

26 May '07

Hello! In a CGI application I was gathering SQL statements I wanted to run in the final transaction. Because I use haskelldb, it was most convenient to use (Database -> IO ()) as the type of the statement or a group of statements. In this representation concatenating two statement groups so they are executed in sequence can be done with: concatStmts s1 s2 = \db -> s1 db >> s2 db My mistake was that I forgot about db and wrote: concatStmts s1 s2 = s1 >> s2 And it was accepted because I had the Monad instance for ((->) r) in scope (from Control.Monad.Trans I guess)! Of course it doesn't do the right thing - s1 is simply ignored. Fortunately I noticed it quite quickly, but I think a similar bug can cause someone a big headache. Perhaps we could move this instance to some separate module, so people won't import it if they don't want it or even don't know about its existence? Best regards Tomek

6 12

Resend: seeking code review
by Justin Bailey 26 May '07

26 May '07

I'm resending my message of yesterday with the code as a zipped attachment. Any and all feedback is welcome. My apologies in advance for the double-post! >From the documentation: "This module provides a set of functions for building simple command-line interfaces. It allows interfaces which collect values (such as Integers, Dates, and more structured values), build lists of values, and use simple menus. It is not intended to build complex interfaces with full cursor control. It is oriented towards line-based interfaces." Justin

1 0

Stack overflow
by Grzegorz 25 May '07

25 May '07

Hi all, I have a simple piece of code which is giving me stack overflow. I guess I need to make it stricter sowhere but I can't figure out extactly where. So I thought I'd ask the experts. import Data.List (foldl') import Control.Monad.State.Strict hammingDistance [] _ = 0 hammingDistance _ [] = 0 hammingDistance (x:xs) (y:ys) | x==y = hammingDistance xs ys | otherwise = 1 + hammingDistance xs ys meanHammingDistanceM xss yss = evalState (mhd xss yss) (0,0) mhd xss yss = do for xss $ \xs -> for yss $ \ys -> do modify (\ (sum,count) -> ((,) $! hammingDistance xs ys + sum) $! count + 1) (sum,count) <- get return $ fromIntegral sum/fromIntegral count where for = flip mapM_ -- Grzegorz

3 4

mac os x installation problem
by Edwin Chen 25 May '07

25 May '07

I'm having some trouble installing ghc on my MacBook (running 10.4). I did ./configure make install but then I get me$ ghci -bash: ghc: command not found So I tried adding /usr/local/bin to my path (that's the default installation location, right?), and now I get me$ ghci dyld: Library not loaded: GNUreadline.framework/Versions/A/GNUreadline Referenced from: /usr/local/lib/ghc-6.6.1/ghc-6.6.1 Reason: image not found Trace/BPT trap Any idea what's wrong? Thanks

5 4

Seeking code review
by Justin Bailey 25 May '07

25 May '07

Fellow Haskellers, I've been working on a library designed to make building simple line-based command line scripts easy and straightforward for some time now. To that end, before I release it I'd like feedback on the code and its design. I've pasted the library below. Unfortunately I had to leave off the documentation and QuickCheck properties as they went over the size limit. Some simple programs that can be built using the library include guess a number (use as "play_game guess_num_fun"): guess_num_fun = do target <- reqIO $ getStdRandom (randomR (1::Integer,100)) let guessed val = case compare target val of GT -> do { reqIO $ putStrLn "Too low!"; return False } LT -> do { reqIO $ putStrLn "Too high!"; return False } EQ -> do { reqIO $ putStrLn "You win!"; return True } reqUntil guessed (prompt "Enter a number between 1 and 100: " reqInteger) play_game game = execReq game Or the ability to collect structured values (use with "getTaxpayer reqTaxpayerEasy") data Taxpayer = Taxpayer { name :: String, age :: Int, ssn :: String } deriving (Read, Show) reqTaxpayerEasy :: Request Taxpayer reqTaxpayerEasy = do name <- prompt "Please enter the tax payer's name: " reqResp age <- prompt "Please enter their age: " reqInt ssn <- prompt "What is their SSN/ASN: " reqResp return (Taxpayer name age ssn) getTaxpayer which = execReq $ do peon <- which reqIO $ putStrLn $ "You entered: " ++ show peon You can also build simple menus (use with "pim"): topMenu = reqMenu $ ("Manage contacts", reqCont manageContactsMenu topMenu) : ("Manage calendar", reqCont manageCalendarMenu topMenu) : [] manageContactsMenu = reqMenu $ ("Add a contact", undefined) : ("Remove a contact", undefined) : ("Return to previous menu", reqFail) :[] manageCalendarMenu = reqMenu $ ("Add an event", undefined) : ("Remove an event", undefined) : ("List events", undefined) : ("Return to previous menu", reqFail) : [] pim = execReq $ reqForever topMenu Except for the examples above, this email is literate haskell if anyone wishes to play with the code. Thanks in advance for any and all feedback! Feel free to contact me if you'd like more examples or the "real" file. Justin --- cut here ---- \begin{code} module HCL ( -- * Request type and related functions. Request, runRequest, execReq, reqIO, makeReq, -- * Request building blocks reqResp, reqInteger, reqInt, reqRead, -- * Functions lifted into Requests andReq, orReq, notReq, reqIf, reqConst, reqLift, reqLift2, reqMaybe, -- * Higher-level Request combinators reqAgree, reqFail, required, reqUntil, reqWhile, reqDefault, reqForever, reqChoices, reqMenu, reqIterate, reqCont, reqWhich, reqFoldl, reqList, -- * Prompting prompt, promptWithDefault, promptAgree ) where import Data.Char (isSpace, toLower, isPrint) import System.IO (hFlush, stdout) import Test.QuickCheck import System.IO.Unsafe (unsafePerformIO) import System.Random import Data.Maybe (isNothing, isJust) {- | The Request data type represents a value requested interactively. The request may have failed or been no response, in which case the request fails. Otherwise, the request holds the response given. -} data Request a = Request (IO (Maybe a)) {- | Runs a request, throws away the result, and returns an IO type (rather than a Request). Useful when a request should just be run and we don't care about the result. Generally used at the top level to evaluate a request in main. -} execReq :: Request a -- ^ Request to run. -> IO () -- ^ No meaningful value is returned. execReq (Request req) = do result <- req maybe (return ()) (\_ -> return ()) result -- | Extracts the value from a given request. runRequest :: Request a -- ^ The request to evaluate. -> IO (Maybe a) -- ^ Result of the request. runRequest (Request r) = r {- | Allows IO operations in the Request type. Same as liftIO in MonadIO class (in Control.Monad.Trans module) -} reqIO :: IO a -- ^ IO action to perform -> Request a -- ^ Result of the IO action, as a Request. reqIO io = Request ioVal where ioVal = do val <- io return $ Just val {- | Request behavior as a Monad covers failure - when a request results in Nothing, all bind operations fail afterwards. Thus, when one request fails, all subsequent requests automatically fail. -} instance Monad Request where return x = makeReq x f >>= g = f `andMaybe` g {- | Takes a value and makes it into a request. Should not be an IO (Maybe a) type value, unless multiply nested values is desired. -} makeReq :: a -- ^ The value to turn into a Request. -> Request a -- ^ The value as a Request. makeReq val = Request (return $ Just val) {- | If the request given results in Nothing, Nothing is returned. Otherwise, the value held in the Just constructor is passed to the "next" function given. This is essentially the bind operation. -} andMaybe :: Request a -- ^ Request to try. -> (a -> Request b) -- ^ Function which processes the result of the previous request and returns a new request. -> Request b -- ^ The new request returned. andMaybe (Request req) next = Request $ do v <- req case v of Nothing -> return Nothing Just x -> nextReqVal where Request nextReqVal = next x {- | The basic request - get a string from the user. If a newline or all whitespace is entered, the request is assumed to be a failure. -} -- Read a string from the user. reqResp :: Request String reqResp = Request $ do val <- getLine if all isSpace val then return Nothing else return $ Just val {- | Gets an Integer from the user. If the value entered cannot be converted, the request fails. -} reqInteger :: Request Integer reqInteger = reqRead reqResp {- | Gets an Int from the user. If the value entered cannot be converted, the request fails. -} reqInt :: Request Int reqInt = reqRead reqResp {- | Uses reads to process a request. If the value cannot be parsed, fails. Otherwise, returns the value parsed. -} reqRead :: (Read a) => Request String -- ^ A request that returns a string (generally 'reqResp'), which will then be parsed. -> Request a -- ^ The value parsed. reqRead req = req `andMaybe` \val -> Request $ do case reads val of [] -> return Nothing ((v, _):[]) -> return $ Just v _ -> return Nothing {- | && operator for requests (with failure). Behaves similarly, including "short-circuit" behavior. If either condition fails, the entire Request fails. -} andReq :: Request Bool -- ^ Left boolean value. -> Request Bool -- ^ Right boolean value. -> Request Bool -- ^ Result value. andReq left right = left `andMaybe` \lb -> Request $ case lb of False -> return $ Just False True -> runRequest right {- | || operator for requests (with failure). Behaves similarly, including "short-circuit" behavior. If either condition fails, the entire Request fails. -} orReq :: Request Bool -- ^ Left boolean value. -> Request Bool -- ^ Right boolean value. -> Request Bool -- ^ Result value. orReq left right = left `andMaybe` \lb -> Request $ case lb of True -> return (Just True) False -> runRequest right -- | not operator for requests. notReq :: Request Bool -- ^ Request to evaluate. -> Request Bool -- ^ Result value. notReq expr = expr `andMaybe` \nb -> Request $ return (Just $ not nb) -- | If statement for requests. reqIf :: Request Bool -- ^ The test to apply -> Request a -- ^ Request to evaluate if test is true. -> Request a -- ^ Request to evaluate if test if false. -> Request a -- ^ Result. reqIf test thenCase elseCase = test `andMaybe` \tb -> if tb then thenCase else elseCase -- | Takes a value and makes it into a request. reqConst :: a -- ^ Value to make into a request. -> Request a -- ^ Result. reqConst val = return val -- | Lifts a one-argument function into Request types. reqLift :: (a -> b) -- ^ Function to lift. -> Request a -- ^ Argument to function. -> Request b -- ^ Result. reqLift f req = do reqVal <- req return (f reqVal) {- | Lifts a 2 argument function into Request types. The arguments to the function are evaluated in order, from left to right, since the Request monad imposes sequencing. -} reqLift2 :: (a -> b -> c) -- ^ Function to lift. -> Request a -- ^ First argument to function. -> Request b -- ^ Second argument to function. -> Request c -- ^ Result. reqLift2 f left right = do leftVal <- left rightVal <- right return (f leftVal rightVal) {- | Returns true if the user answer y or Y. Allows a default to be specified, and allows failure if no default is given. -} reqAgree :: Maybe Bool -- ^ Default value (if any). -> Request String -- ^ Request which gets a string (usually reqResp). -> Request Bool -- ^ Result. reqAgree def req = Request result where Request result = reqMaybe req (Request returnDefault) (Request . returnAgreement) returnDefault = return $ maybe Nothing (\d -> Just d) def returnAgreement resp = case clean resp of ('y':_) -> return $ Just True ('n':_) -> return $ Just False _ -> returnDefault clean = (map toLower) . filter (not . isSpace) -- | Automatic failure. Useful in menus to quit or return to the previous menu. reqFail :: Request a reqFail = Request $ return Nothing {- | Takes a request and guarantees a value will be returned. That is, the request is repeated until a valid (i.e. not Nothing) response is returned. -} required :: Request a -- ^ Request to evaluate. -> Request a -- ^ Result. required (Request req) = Request required' where required' = do val <- req case val of Nothing -> required' Just v -> return (Just v) {- | Like the maybe function, but for requests. Given a request value, a default value,and a function that maps b to Request a, this function either returns the default if the request value is nothing, or it applies the function given to the value of the request and returns it. -} reqMaybe :: Request a -- ^ Request to evaluate. -> Request b -- ^ Default value. -> (a -> Request b) -- ^ Function to map b to Request a. -> Request b -- ^ Result. reqMaybe (Request req) (Request def) fun = Request $ do val <- req case val of Nothing -> def Just v -> nextReqVal where Request nextReqVal = fun v {- | Runs the request while the condition given holds, then returns the result. Good for verification. -} reqWhile :: (a -> Request Bool) -> Request a -> Request a reqWhile cond req = do reqVal <- req testVal <- cond reqVal if testVal then reqWhile cond req else return reqVal {- | Runs the request until the condition given is satisfied, then returns the result. -} reqUntil :: (a -> Request Bool) -- ^ Condition to test. -> Request a -- ^ Request value to evaluate according to test. -> Request a -- ^ Result. reqUntil cond req = reqWhile ((reqLift not) . cond) req {- | Requests a response from user. If Nothing is returned, assumes default and returns that. -} reqDefault :: Request a -- ^ Request to evaluate. -> a -- ^ Default value. -> Request a -- ^ Result. reqDefault req def = Request $ do val <- runRequest req case val of Nothing -> return $ Just def v -> return v -- Ask a request forever (or until failure). reqForever :: Request a -- ^ Request to ask forever. -> Request a -- ^ Result. reqForever req = req `andMaybe` \_ -> reqForever req {- | Given a list of items and programs to run, displays a menu of the items and runs the selected program. Very low level - usually reqMenu is used instead. If the user selects an invalid choice, failure occurs. -} reqChoices :: [(String, a)] -- ^ List of choices and labels which will be selected from. -> Request Int -- ^ Request which gets the selection from the user. -> Request a -- ^ Result of selection. reqChoices choices req = do let choiceCnt = length choices choiceList = zip [(1::Int)..] (map (\(label, _) -> label) choices) sequence (map (\(idx, label) -> reqIO $ putStrLn ((show idx) ++ ". " ++ label)) choiceList) idx <- prompt "? " req if idx < 1 || idx > length choices then reqFail else return (snd (choices !! (idx - 1))) -- | Takes a list of strings and requests and forms a menu out of them. Usually used over reqChoices. reqMenu :: [(String, Request a)] -- ^ List of request choices and labels. -> Request a -- ^ Result. reqMenu choices = do choice <- reqChoices choices reqInt choice {- | Takes an initial value and function which produces a request from that value. Applies the function to the initial value and then recurses. Useful for functions which operate off their own output (e.g. a shell maintaining an environment). -} reqIterate :: (a -> Request a) -- ^ Iterative function which transforms a to Request a. -> a -- ^ Initial value used. -> Request a -- ^ Result of evaulation. reqIterate fn initial = do result <- fn initial reqIterate fn result {- | Takes a request and a "continuation" request. If the first request results in Nothing, run the second request. In either case, return the result of the successful request. -} reqCont :: Request a -- ^ First request to evaluate. -> Request a -- ^ Continuation request which is evaluated if first fails. -> Request a -- ^ Result. reqCont req cont = do result <- reqWhich req case result of Left _ -> cont Right val -> return val {- Indicates if the request failed or succceeded. If Left () is returned, the request failed. If Right v is returned, the request produce a value. Though the value returned is itself a request, it will always be valid. -} reqWhich :: Request a -- ^ Request to evaluate. -> Request (Either () a) -- ^ Result. reqWhich req = do let -- default value, indicating a bad selection was made. failed = Request (return (Just (Left ()))) -- Indicates a valid item was selected. success val = Request (return (Just (Right val))) reqMaybe req failed success {- | Give a function from a -> b, an initial value, and a Request for a, builds a Request for b. When (Request a) fails, then the function returns whatever (Request b) has been built. -} reqFoldl :: (a -> b -> Request b) -- ^ Accumulating function. -> b -- ^ Initial value. -> Request a -- ^ Request to evaluate. -> Request b -- ^ Result. reqFoldl fn initial req = reqFoldl' initial where reqFoldl' acc = do result <- reqWhich req case result of Left _ -> return acc Right val -> do result <- fn val acc reqFoldl' result {- | Given a request, builds a list of response. When the user enters nothing, the list building ends -} reqList :: Request a -- ^ Request to evaluate. -> Request [a] -- ^ Result. reqList req = reqFoldl (\l ls -> return (l:ls)) [] req {- | Prints a message and makes a request. If the message ends in a space, it is assumed that the user should enter values on the same line. Otherwise, a new line is printed and the reqeust is evaulated. -} prompt :: String -- ^ Message to display. -> Request a -- ^ Request which gathers input -> Request a -- ^ Result. prompt msg (Request req) = Request $ do if isSpace (last msg) then putStr msg else putStrLn msg hFlush stdout val <- req return val {- | Displays a message prompt and a default choice in a common way. If the user doesn't provide a choice or enters bad data, the default value provided is returned. Otherwise, the value entered is returned. -} promptWithDefault :: (Show a) => String -- ^ Message to display. Follows conventions of 'prompt'. -> Request a -- ^ Request to evaluate. -> a -- ^ Default value to use if necessary. -> Request a -- ^ Result. promptWithDefault msg req def = let msgWithDefault = msg ++ " [" ++ show def ++ "] " in prompt msgWithDefault (reqDefault req def) {- | Prints a message, displays defaults (if any), and turns a Request String into a Request Bool. If a default value is provided, it will be returned if the user enters nothing or an invalid response. -} promptAgree :: String -- ^ Message to display. Follows conventions of 'prompt'. -> Maybe Bool -- ^ Default value, if any. -> Request String -- ^ Request which gets a string (usually reqResp). -> Request Bool -- ^ Result. promptAgree msg def req = prompt msgWithDefault (reqAgree def req) where msgWithDefault = maybe msg (\v -> if v then (msg ++ "(Y/n) ") else (msg ++ "(y/N) ")) def \end{code}

1 0

global variables
by Eric 25 May '07

25 May '07

H|i, Does anyone know of a simple and straightforward way to use global variables in Haskell? E.

22 48

binary file handling (was: no subject)
by Paul R. Potts 25 May '07

25 May '07

Hello all, Ketil Malde wrote: > This is what I find in System.IO (ghci> :b System.IO): > > openBinaryFile :: FilePath -> IOMode -> IO Handle > openBinaryTempFile :: FilePath -> String -> IO (FilePath, Handle) > hSetBinaryMode :: Handle -> Bool -> IO () > > so you have the option of either using openBinaryFile or openFile and > using hSetBinaryMode to true. I guess - I've never had to use them. > > I can't find a readBinaryFile either, but writing one might be a good > excercise? > > Makes me wonder whether one should have binary be the default? I'm a > stranger in Windows-land, but are there cases where you want reading of > a file to be terminated on ^Z? Seems pretty awful to me. I ran into this same problem when trying to write a binary file filter; see: http://praisecurseandrecurse.blogspot.com/2007/04/haskell-for-short-attenti… Back then I got some help on #haskell to figure out how to write ReadBinaryFile. I got that working, and wrote "This works fine, although I would humbly suggest that GHC's standard library should provide easy access to binary files; while the solution is pretty trivial, it is a wart." I would not go so far as to say that binary should be the default mode for opening and reading a file, but I would say that the two should be made equally simple and clear options in the standard library. Paul R. Potts -- Paul R. Potts - paul(a)thepottshouse.org - http://thepottshouse.org

1 0

How to selectively export internal entities from a module for testing?
by Thorkil Naur 24 May '07

24 May '07

Hello, It is common practice to export only selected entities from a Haskell module and refrain from exporting other entities so that they are only available for internal use. There are many reasons for wanting to do this, such as reducing the number of importable entities, avoiding the exposure of internal details that may therefore more easily be changed, and to enable certain optimizations (http://haskell.org/haskellwiki/Performance/Modules) However, for one particular use, namely automated testing, it often seems useful, even necessary, to allow even entities considered internal to be exported: If internal entities cannot be imported by the testing code, they can only be tested indirectly, via the exported entities, and that may turn out to be troublesome. A possibility would be to include the testing code in the module itself, but that seems clumsy and wasteful. For possible guidance, I have looked at http://darcs.haskell.org/packages/filepath and System/FilePath/Internal.hs contains > -- Note: leave this section to enable some of the tests to work > #ifdef TESTING > -- * Drive methods > splitDrive, joinDrive, > takeDrive, replaceDrive, hasDrive, dropDrive, isDrive, > #endif precisely to allow automated testing. And that, of course, solves the problem. But I am wondering whether other solutions to this problem could be found, perhaps even solutions that stay within the limits of the Haskell language itself? If anybody know of alternative solutions, I would very much like to hear about them. Thanks and best regards Thorkil

2 1

Re: Re: [Haskell-cafe] (no subject)
by L.Guo 24 May '07

24 May '07

to Ketil : Tring openBinaryFile, I notice that I cannot make one usable buffer, just because I can not find one function to "malloc" a memory or just get one "change-able" buffer. :-$ to Marc: I can not locate which module including readBinaryFile. And I use hoogle search engine. Could you give me some more hints ? ------------------ L.Guo 2007-05-24

4 6

(no subject)
by L.Guo 24 May '07

24 May '07

Hi MailList Haskell-Cafe: Till now, which module / package / lib can i use to access binary file ? And is this easy to use in GHC ? Regards -------------- L.Guo 2007-05-24

4 7

Should "do 1" compile
by Neil Mitchell 24 May '07

24 May '07

Hi, As discussed on #haskell, the following code: ---------------- module Foo where foo = do (1 :: Int) ---------------- Compiles fine on Yhc, but doesn't on Hugs and GHC. GHC: Couldn't match expected type `t t1' against inferred type `Int' In the expression: (1 :: Int) In the expression: do (1 :: Int) In the definition of `foo': foo = do (1 :: Int) Hugs: ERROR "test.hs":4 - Type error in final generator *** Term : 1 *** Type : Int *** Does not match : a b So the question is, who is right? Where do the bugs need filing? Does this issue need clarifying for Haskell' ? Thanks Neil

11 15

Software Engineer, Functional Programmer, Team/Project lead positions
by Isaac Jones 24 May '07

24 May '07

Are you seeking an intellectually challenging position in which you'll be developing cutting edge software using functional programming technologies? Do you aspire to work with a team that shares your level of commitment and enthusiasm to develop tomorrow's high-assurance technology today? Do you want to take ideas and turn them into real-world products? If so, you might be just the person we're looking for. Galois Connections, Inc., located near Portland, Oregon, designs and develops high confidence software for critical applications using cutting edge methods and technology. Innovative and highly creative in the demanding application areas of security, information assurance, cross-domain platform development, and formal-methods engineering, Galois has earned a reputation of excellence in both private and government sectors. Galois has recently opened several positions for software engineers/ functional programmers and team leads who will participate in/lead projects from inception to product delivery. These people will work in a highly cooperative and collaborative team settings and will be responsible for ensuring the delivery of robust and fully functional products according to client expectations and potential certifying agencies. For more details about these exciting opportunities please go to: http://www.galois.com/join.php To learn more about Galois visit our website at http://www.galois.com

1 0

Re: [Haskell-cafe] Currying: The Rationale
by Chad Scherrer 24 May '07

24 May '07

Is (^2) really considered currying? As I understand it, this is syntactic sugar for a "section", and might confuse the issue a bit, since it's distinct from ((^) 2). In this case we would have something like Prelude> let pow2 = ((^) 2) Prelude> map pow2 [1..10] [2,4,8,16,32,64,128,256,512,1024] I think it's also worth pointing out that currying can make point-free programming more natural. So, foldl has type Prelude> :t foldl foldl :: (a -> b -> a) -> a -> [b] -> a That this could have been defined as foldlUncurried :: ((a -> b -> a), a, [b]) -> a but then simple point-free definitions like sum = foldl (+) 0 would have to be written as sum xs = foldlUncurried ((+), 0, xs) OTOH, sometimes an uncurried version is easier to reason about. So, in some of Richard Bird's work ("Algebra of Programming" is like this, and probably at least some of his intro book) examples are uncurried, as it shows more of the algebraic structure, and allows reasoning in a product space rather than an exponential. Umm, I guess that qualifies as jargon - sorry. Chad > (^) applied to 2, produces a new function, we can map over a list: > > Prelude> let sq = (^2) > Prelude> map sq [1..10] > [1,4,9,16,25,36,49,64,81,100] > > or more explicitly: > > Prelude> let x `to` y = x ^ y > Prelude> let sq x = x `to` 2 > Prelude> map sq [1..10] > [1,4,9,16,25,36,49,64,81,100] > > -- Don

4 4

Currying: The Rationale
by PR Stanley 24 May '07

24 May '07

Hi What is the rationale behind currying? is it for breaking subroutines into pure one-to-one mappings? If f x y = f x -> a function which takes y for argument then does that mean that the second function already has value x, as it were, built into it? The syntax in Haskell is perfectly lucid and almost intuitive; unlike the underlying theory which is a bit ... top marks for the least jargoned answer. Many thanks in advance, Paul

5 5

efficient and/or lazy partitions of a multiset
by Greg Meredith 23 May '07

23 May '07

HC-er's, Find below some simple-minded code from a naive Haskeller for generating all partitions of a multiset about which i have two questions. mSplit :: [a] -> [([a], [a])] mSplit [x] = [([x],[])] mSplit (x:xs) = (zip (map (x:) lxs) rxs) ++ (zip lxs (map (x:) rxs)) where (lxs,rxs) = unzip (mSplit xs) 1. Is there a clever way to reduce the horrid complexity of the naive approach? 2. How lazy is this code? Is there a lazier way? i ask this in the context of checking statements of the form \phi * \psi |= e_1 * ... * e_n where - [| \phi * \psi |] = { a \in U : a === b_1 * b_2, b_1 \in [| \phi |], b_2 \in [| \psi |] } - === is some congruence generated from a set of relations A nice implementation for checking such statements will iterate through the partitions, generating them as needed, checking subconditions and stopping at the first one that works (possibly saving remainder for a rainy day when the client of the check decides that wasn't the partition they meant). Best wishes, --greg -- L.G. Meredith Managing Partner Biosimilarity LLC 505 N 72nd St Seattle, WA 98103 +1 206.650.3740 http://biosimilarity.blogspot.com

2 4

Editor
by Michael T. Richter 23 May '07

23 May '07

I have a dream. It's not a little dream. It's a big dream. I have a dream that someday I can find a UNIX/Linux text editor for Haskell hacking (and possibly two or three hundred other programming languages, although that's optional) that can give me all of the following: 1. A real GUI environment that takes into account some of the HID advances made in the past 30 years. (Emacs and Vim don't count, in other words.) 2. Good quality syntax highlighting for Haskell that includes all of the usual syntax highlighting goodies, plus: * the ability to seamlessly handle raw Haskell and both common forms of Literate Haskell; * the ability to properly highlight Haddock comments; * the ability to highlight functions and types from libraries (user-expandable) differently from local functions and types. 3. Line folding to hide and show blocks of code. 4. Code completion (user-expandable, ideally) for common library functions, type declarations, etc. 5. Easy, quick access to online documentation for said functions and declarations. 6. Good (ideally scriptable) access to external utilities for compilation, debugging, profiling, type inference, project management, etc. 7. A good plug-in system (ideally written in Haskell?) for expansion. Is there such a beast available out there somewhere? If not, is such a beast lurking in the background ready to pounce in the near future? -- Michael T. Richter <ttmrichter(a)gmail.com> (GoogleTalk: ttmrichter(a)gmail.com) I have to wonder why people think that when they can't manage local personnel within easy strangling and shooting distance, then they can manage personnel thousands of miles away that have different languages, cultures, and business rules. (Joe Celko)

26 39

Re: [Haskell-cafe] New book: Real-World Haskell!
by Alfonso Acosta 23 May '07

23 May '07

On 5/23/07, Donald Bruce Stewart <dons(a)cse.unsw.edu.au> wrote: > > Bryan O'Sullivan, Don Stewart and John Goerzen are pleased, and frankly, > very excited to announce that were developing a new book for O'Reilly, on > practical Haskell programming. The working title is Real-World Haskell. That is simply great! I've been looking forward to read a book like that for so long. > 28. Advanced Haskell: MPTCs, TH, strong typing, GADTs Existential types are a must in this chapter! even more important that TH and GADTs.

1 0

type class question
by Tim Docker 23 May '07

23 May '07

I think this must almost be a FAQ, or at least a PAQ (Previously AQ)... If I have a type class for conversion to a type X: class XType a where toX :: a -> X I can define instances for instance XType Int where toX = ... instance XType Double where toX = ... instance XType Tuple where toX = ... but not for Strings, given that they are a synonym for [Char]. Hence: instance XType String where toX = ... results in: Illegal instance declaration for `XType String' (The instance type must be of form (T a b c) where T is not a synonym, and a,b,c are distinct type variables) In the instance declaration for `XType String' Is there some type class cleverness that can make this work in haskell 98? I can create a new wrapper type for strings: newtype StringWrap = StringWrap String and write an instance for that, but then I'll have to litter my code with calls to this constructor. I'm aware of the approach taken by class Show in the prelude, which adds a extra method to the class: class XType a where toX :: a -> X listToX :: [a] -> X but I believe this says that whenever we can convert a to an X we can also convert [a] to an X, whereas I only want [Char] to be acceptable. Thanks for any pointers. Tim

4 5

Re: [Haskell] boilerplate boilerplate
by Jacques Carette 23 May '07

23 May '07

Personally I would like {-# OPTIONS -fglasgow-exts -fgenerics -} module Blog.Types where family Usual = (Eq, Ord, Read, Show, Typeable) data BlogEntry = Entry EpochSeconds Name Email Title Body deriving Usual newtype Name = Name String deriving Usual newtype Title = Title String deriving Usual newtype Body = Body String deriving Usual Of course, if you're doing that, you might as well change those last 3 lines with newtype-schema NamedString = NamedString String deriving Usual instantiate NamedString with Name, Title, Body To me, that is very clear. Syntax-wise, I am sure things can be improved (but I rather like 'family', 'foo-schema' and 'instantiate', but not really the 'with'). Jacques Alex Jacobson wrote: > Consider this module for a blog entry that I will want to put in > various generic collections that require Ord > > {-# OPTIONS -fglasgow-exts #-} > module Blog.Types where > import Data.Typeable > import Data.Generics > > data BlogEntry = Entry EpochSeconds Name Email Title Body > deriving (Eq,Ord,Read,Show,Typeable) > > newtype Name = Name String deriving (Eq,Ord,Read,Show,Typeable) > newtype Title = Title String deriving (Eq,Ord,Read,Show,Typeable) > newtype Body = Body String deriving (Eq,Ord,Read,Show,Typeable) > > > It seems really unnecessarily verbose. Having to add the OPTION > header AND import Data.Typeable and Data.Generics just to derive > Typeable is a beat-down. It is even more of a beat-down to have to > add a deriving clause for every newtype to make this all work nicely. > Is there a way to make all types automatically derive everything > unless there is an explicit instance declaration otherwise? > > {-# OPTIONS -fglasgow-exts -fgenerics -fderiving#-} > module Blog.Types where > > data BlogEntry = Entry EpochSeconds Name Email Title Body > newtype Name = Name String newtype Title = Title String newtype > Body = Body String > Isn't that much nicer? > > -Alex- > > > _______________________________________________ > Haskell mailing list > Haskell(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell

1 0

How do I insert an element in HaXml?
by Jeremy Shaw 23 May '07

23 May '07

Hello, How do I create a HaXml filter that adds a new element as a child of an existing element. For example, let's say I have the XML document: <a> <b/> <c/> </a> How do I add a new element under <a /> so that I have the document: <a> <newElement/> <b/> <c/> </a> The following works, but it seems very hackish because I have to use the underlying HaXml data types. I think I could possibly use the filters in Text.XML.HaXml.Xtract.Combinators, but that seems like overkill for such a seemingly simple (and common?) operation. import Text.XML.HaXml import Text.XML.HaXml.Types import Text.XML.HaXml.Pretty insertNewElement = extract (\(CElem (Elem name _as cs)) -> mkElem name [mkElem "newElement" [] , const cs]) where extract :: (Content -> CFilter) -> CFilter extract f = \c -> f c undefined -- these are just helper functions to invoke my filter. But, I'll -- happily accept improvements to these functions as well ;) main = print $ document $ runFilter "<a><b /><c /></a>" insertNewElement runFilter :: String -> CFilter -> Document runFilter xmlStr cfilter = let (Document p s e m) = xmlParse "" xmlStr in case (cfilter (CElem e)) of [CElem e'] -> Document p s e' m [] -> error "produced no output" _ -> error "produced more than one output" thanks! j.

2 3

List algorithm
by Steffen Mazanek 22 May '07

22 May '07

Hello, is there an efficient algorithm that takes two positive numbers n and m and that computes all lists l of numbers 0<x<=n such that sum l = m? For instance alg 5 1 = [[1]] alg 5 2 = [[1,1],[2]] alg 5 3 = [[1,1,1],[1,2],[2,1],[3]] ... I know that filter (\l->sum l == m) (powerSet [1..n]) would do the job, however I am looking for a more efficient approach. Help is greatly appreciated, even a google search term would be fine :-) I really hope for a polynomial algorithm although I am not very optimistic about this. Ciao, Steffen

8 11

Re: [Haskell-cafe] Ann: Emping 0.2
by Hans van Thiel 22 May '07

22 May '07

On Mon, 2007-05-21 at 14:06 -0700, Scott Cruzen wrote: > Is Emping an implementation of C4.5 or something new? No, it's new. The reduction algorithm is not based on a measure and is not a search either. It's a construction of predicate combinations, starting with singletons, that are not contradictory to known facts. The third step, following hypothesis and then falsification, is verification with observed rules. The complexity appears to be quadratic to the original rule length and also to the number of original rules, but I have yet to prove this. I believe I have proved that the algorithm produces the complete and shortest disjunctive normal form of a logical rule table. The white paper 'Deriving heuristic rules from facts' http://j-van-thiel.speedlinq.nl/dwnl/EmpingWP.pdf (21 pages) discusses the theory from examples, and an earlier wp (also available on the web site) uses some first order predicate logic and set theory. Version 0.2 also shows logical dependencies in the reduced rules and this is just a search in the original rules and in the poset of reductions. So this is not new in a theoretical sense, though I believe no other implementation has ever considered such dependencies. Regards, Hans van Thiel > > * Hans van Thiel <hthiel.char(a)zonnet.nl> [070521 05:45]: > > Hello All, > > > > Version 0.2 of Emping, a utility to derive heuristic rules from a table > > of nominal data, is available. In addition to a reduced normal form > > in .csv format, which can be read by Open Office Calc, it now also > > displays observed implications and equivalences in the reduced rules (if > > present) and ambiguities in original rules (if present). > > A bug in the response to a user typing error has been fixed and some > > code has been simplified, compared to 0.1. An online user guide is at: > > http://j-van-thiel.speedlinq.nl/emp/empug.html and the Cabal package can > > be downloaded from there, or from the HackageDB. > > > > Thanks, > > > > Hans van Thiel > > > > > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe(a)haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

RE: [Haskell] Inaugural London HUG meeting; attendee list suggestion
by Bayley, Alistair 22 May '07

22 May '07

[this time to the list :-] > > Should we start something here, perhaps? > > > http://www.haskell.org/haskellwiki/London_Haskell_User_Group/Events/2007 0426 > > Sounds a plausible idea, but shouldn't it be 20070523? > > Jeremy Yeah... sorry, I totally fished that date out of a body cavity. I think it was the date of the original blog post about the meeting. Corrected URL: http://www.haskell.org/haskellwiki/London_Haskell_User_Group/Events/2007 053 Is that a good way to label the event, though? If it needs to change dates then the URL changes, which isn't so good. An alternative might be a sequence number e.g.: http://www.haskell.org/haskellwiki/London_Haskell_User_Group/Events/LHUG -1 Alistair ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

1 0

Inaugural London HUG meeting; attendee list suggestion
by Bayley, Alistair 22 May '07

22 May '07

Tomorrow evening's London Haskell User Group meeting has a reasonable list of attendees (inferred from the comments): http://www.londonhug.net/2007/04/26/announcement-first-meeting-of-the-lo ndon-haskell-user-group/ I think it'd be a good idea to do what the BCS-SPA does, and maintain a wiki-page where attendees can add/remove themselves e.g. http://bcs-spa.org/cgi-bin/view/SPA/MakingSenseOfInformalInformation (scroll down to bottom of page, above map) This gives a current picture of who's planning to attend, which might be useful if you want to catch up with particular people. Should we start something here, perhaps? http://www.haskell.org/haskellwiki/London_Haskell_User_Group/Events/2007 0426 Alistair ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

1 0

Wanted: extended static checking for xmonad
by dons＠cse.unsw.edu.au 22 May '07

22 May '07

When working on xmonad, we're trying to produce very clean, correct code -- a window manager that just works. To do this, we're looking to employ more static checking tools to the code base. Currently we use: * QuickCheck (checks high level window manager behaviour) * Catch (Neil's pattern match verifier, caught a couple of bugs) * ghc -Wall One other tool we're considering: * HPC. check program coverage of the test suite. But I suspect that there's an awful lot of other small checkers of various kinds out there. So: * Do you know of some other cool code checking tool for Haskell? * That could be used on xmonad (xmonad.org) to reduce code smell? If so, let us know! :-) -- Don P.S. Perhaps it is time for a wiki page documenting the available extended static checking tools for Haskell.

1 0

How Albus Dumbledore would sell Haskell
by Dan Weston 22 May '07

22 May '07

It is unscientific to ask the (highly biased) people on this list how to sell Haskell. A focus group of the target audience is clearly called for. Having said that, I will now violate my own advice. Knowledge of the audience is critical to the success of a presentation. Simon (aka Dumbledore) is speaking to four different Houses: scientists (Ravenclaw), engineers (Hufflepuff), entrepreneurs (Slytherin), and managers (Griffindor). My advice to him is: You have already won over the scientists. Stop priming the pump. Algebraic runes, spells from the Book of Category Theory, bananas, lenses, arrows, cata, ana, hylo, endo, all is vanity. You cannot interest the engineer with new tricks. He has spent too long mastering difficult tricks to work around limitations to want to see them eliminated. His competitive advantage and prized reputation are at stake. Get him to believe that he is on the verge of being "left behind". You cannot win over the entrepreneur with promises of "easier and more robust". This translates to "anyone can do it" and the valuable "trade secret" of arcane wizardry is now devalued. Show something exciting that cannot be done (or would never have been attempted) without FP. Monads, CPS, existential data types, or other high-priestess wizardry are no impediment (less competition from lesser peers). But marginal improvement is unimpressive. A new language brings high risk, and must have high reward. Examples must be powerful (not another prime number generator). Effective complexity management, correctness reasoning in concurrent/distributed processing, and so on will get their interest. Risk is scary for managers. "Great promise" promises the manager only headaches. This translates to "no one can be hired to do it" and "those that can will shake me down for more money". You must promote instead the *inevitability* of Haskell's success: the fact that Haskell has recently dominated the ICFP Programming Contest, the strongly upward trend of Haskell taught at universities (hopefully there is a strongly upward trend?), some anecdotal measure of the predisposition to relatively better "quality" of those who seek to learn Haskell. Allay the unspoken fear that there are always plenty of Haskellers to cause trouble in a company (design and implement great tasks), but never enough more mediocre Haskellers to keep out of trouble (content to do "maintenance" tasks and minor upgrades to existing software) by marketing Haskell as a recruitment tool to attract the best, a motivational tool to reenergize engineers (see above) who've let their skills go stale in larger companies, and a staff-development tool to spur internal friendly competition to modernize their skills (and excuse wage stagnation in those that do not). Since "inevitability" is a hard sell for Haskell right now, avoid mentioning ML or Erlang. There needs to be only one FPL for a manager, or he will fret about VHS vs. Betamax syndrome (and he won't want to have been the one to invest in a Betamax). Don't show any Haskell function with the prefix "unsafe". Even now, I find the name unsettling. The Harry Potter series makes money because we can't do magic but we want to. It is human nature that what is given away will never be thought to have value. Don't give away the magic of Haskell. Let the audience in on the secret that the Haskell wizarding world is doing great things with it for glory and profit, and others will steal the secret for themselves readily enough. If Simon can do all this, then he really is worthy of the name Dumbledore. :) Dan

25 32

Haskell: the Craft of Functional Programming
by PR Stanley 22 May '07

22 May '07

Hi I've acquired a copy of the above title but it requires a lot of transcription work. So, I thought I'd first ensure it's worth the time and effort. This edition was published in 1999. All Opinions on the text, good or bad, would be very welcome. Thanks, Paul

3 3

Profiling, GUIs and libraries
by Anthony Chaumas-Pellet 22 May '07

22 May '07

Hello, I'm currently hacking away a wxhaskell program that uses up 100% CPU even when it should be idle. So, rather than doing blind guesswork, I've thought about using profiling to spot the zealous function. I do not need a very accurate result, though. ghc with -prof -auto(-all) produces the following error message, however: "Could not find module `Graphics.UI.WX': Perhaps you haven't installed the profiling libraries for package wx-0.10.1? Use -v to see a list of the files searched for." So, I guess I need to rebuild wx with profiling, but I'm not sure how to do that exactly; <search engine> and the Wiki did not turn up any pointers, and there are no ready-made options to build wx with profiling. It seems Cabal can build a library with profiling automatically, but I don't think there exists a Cabalized version of wx yet. That, and I'm not sure if recompiling libraries to add profiling is a great idea, as wx itself may depend on other external libraries. So, is there a better way than profiling in my case, or am I missing something obvious here? Thanks! Anthony

3 3