- Haskell-Cafe - Haskell.org

String Hashing
by Thomas Conway 19 Jun '07

19 Jun '07

Hi All, I'm trying to figure out how to maximum performance out of one of my inner loops which involves string hashing. Consider the following hash function, which is a transliteration of a good one written in C: --8x--8x--8x--8x--8x--8x--8x--8x--8x module HashStr where import Data.Bits import Data.ByteString as BLOB import Data.Word data Triple = Triple !Word64 !Word64 !Word64 hashStr :: ByteString -> Word64 hashStr str = hashBlock (Triple gold gold gold) str where gold = 0x9e3779b97f4a7c13 hashBlock (Triple a b c) str | BLOB.length str > 0 = hashBlock (mix (Triple a' b' c')) rest | otherwise = c where a' = a + BLOB.foldl' make 0 (slice 0) b' = b + BLOB.foldl' make 0 (slice 1) c' = c + BLOB.foldl' make 0 (slice 2) make x w = (x `shiftL` 8) + fromIntegral w slice n = BLOB.take 8 $ BLOB.drop (8 * n) str rest = BLOB.drop 24 str mix :: Triple -> Triple mix = (\(Triple a b c) -> Triple (a - c) b c) . (\(Triple a b c) -> Triple (a `xor` (c `shiftR` 43)) b c) . (\(Triple a b c) -> Triple a (b - c) c) . (\(Triple a b c) -> Triple a (b - a) c) . (\(Triple a b c) -> Triple a (b `xor` (a `shiftL` 9)) c) . (\(Triple a b c) -> Triple a b (c - a)) . (\(Triple a b c) -> Triple a b (c - b)) . (\(Triple a b c) -> Triple a b (c `xor` (b `shiftR` 8))) . (\(Triple a b c) -> Triple (a - b) b c) . (\(Triple a b c) -> Triple (a - c) b c) . (\(Triple a b c) -> Triple (a `xor` (c `shiftR` 38)) b c) . (\(Triple a b c) -> Triple a (b - c) c) . (\(Triple a b c) -> Triple a (b - a) c) . (\(Triple a b c) -> Triple a (b `xor` (a `shiftL` 23)) c) . (\(Triple a b c) -> Triple a b (c - a)) . (\(Triple a b c) -> Triple a b (c - b)) . (\(Triple a b c) -> Triple a b (c `xor` (b `shiftR` 5))) . (\(Triple a b c) -> Triple (a - b) b c) . (\(Triple a b c) -> Triple (a - c) b c) . (\(Triple a b c) -> Triple (a `xor` (c `shiftR` 35)) b c) . (\(Triple a b c) -> Triple a (b - c) c) . (\(Triple a b c) -> Triple a (b - a) c) . (\(Triple a b c) -> Triple a (b `xor` (a `shiftL` 49)) c) . (\(Triple a b c) -> Triple a b (c - a)) . (\(Triple a b c) -> Triple a b (c - b)) . (\(Triple a b c) -> Triple a b (c `xor` (b `shiftR` 11))) . (\(Triple a b c) -> Triple (a - b) b c) . (\(Triple a b c) -> Triple (a - c) b c) . (\(Triple a b c) -> Triple (a `xor` (c `shiftR` 12)) b c) . (\(Triple a b c) -> Triple a (b - c) c) . (\(Triple a b c) -> Triple a (b - a) c) . (\(Triple a b c) -> Triple a (b `xor` (a `shiftL` 18)) c) . (\(Triple a b c) -> Triple a b (c - a)) . (\(Triple a b c) -> Triple a b (c - b)) . (\(Triple a b c) -> Triple a b (c `xor` (b `shiftR` 22))) --8x--8x--8x--8x--8x--8x--8x--8x--8x Obviously, we'd like all those lambdas and composes to be inlined, along with all the intermediate Triple structures. So, how do you convince ghc to do this? Alternatively, how would you *translate* rather than transliterate, the mix function? -- Dr Thomas Conway drtomc(a)gmail.com Silence is the perfectest herald of joy: I were but little happy, if I could say how much.

6 12

Re: [Haskell-cafe] embedded build language?
by Tomasz Zielonka 19 Jun '07

19 Jun '07

[I hope you don't mind that I send this letter to haskell-cafe too. I thought someone else might be interested.] On Mon, Jun 18, 2007 at 10:52:40AM -0700, Greg Fitzgerald wrote: > >first let's see if anybody likes the general idea > Would you mind describing the role of Depends.hs in your architecture? After parsing the target file name, you have to list the files this target depends on. This list is used by the engine to check if a rebuild is neccesary, or if some required files are missing. To add a file to the dependency list, you call "require" in Depends monad. "require" returns the file name it was given, so you can do things like: matchExact "prog" $ do o_files <- sequence [ require "a.o" , require "b.o" , require "c.o" ] return $ do system ("gcc -o prog " ++ unwords o_files) The Writer part of the Depends is used to gather the list. In the example above, you could also use listen: listen :: (MonadWriter w m) => m a -> m (a, w) but I'm not sure if it's good to expose the MonadWriter interface. I think I will provide my version of listen in Depends anyway. The Reader part is currently used for a very simple thing - it supplies the target name as a hidden parameter. This allows for an easy way to get the target name regardless of the matching mechanism used. > How did you decide on using the Reader and Writer monads? This was the most natural, and the easiest, choice. > If you have multiple matching rules, should one take precedence? Right now in such situation an error will be raised. This of course may be insufficient in some cases. Depending on the circumstances, you may want to: - raise an error (like now) - choose one of the rules, perhaps based on some priorities or policies, like "most specific first" - merge the rules, somehow I haven't thought about those issues too much, but I would prefer to allow the rule author to decide. Best regards Tomek

1 0

IDE?
by bf3＠telenet.be 19 Jun '07

19 Jun '07

I've searched the internet for an Haskell IDE that supports the following: - syntax highlighting - cross module refactoring - quick navigation (goto symbol, goto instance, find usages, etc) - code completion - "debugging" (not imperative debugging, so no breakpoints, but just plugging in a visualizer/pretty printer for a function in a separate dedicated window, like what http://www.apple.com/shake does on each "node") So a bit what Jetbrains Resharper does for Visual Studio, but for Haskell. IntelliJ and Eclipse also do this for Java. This does not seem to exist? If this is correct, this is a real shame, because although I read that the productivity increases a lot when correctly using Haskell, it would increase even more when such an IDE is available. Any help to find an IDE that comes closest to these features would be much appreciated. Thanks, Peter

22 50

Efficient signal processing
by Henning Thielemann 19 Jun '07

19 Jun '07

I always thought that signal processing must be a good benchmark for compiler optimizations and optimizer rules of libraries like 'binary' and 'fps'. Many signal processing functions process a signal from the beginning to the end with a little of state, thus in many cases I expect that they can be translated to simple loops. However, I still cannot get the necessary speed for real-time processing out of 'binary' and 'fps'. In my setup a signal is of type [Double]. After a series of sound transformations a signal is finally converted to [Int16] and then to ByteString. Can I expect that interim signals represented as lists are optimized away? I have simple example which writes zeros to disk. The content of the first file is created by ByteString.replicate for the purpose of comparison with the second file. With the second file I want to check the speed of the conversion from [Int16] to ByteString. module Main (main) where import System.Time (getClockTime, diffClockTimes, tdSec, tdPicosec) import qualified Data.ByteString.Lazy as B import qualified Data.Binary.Put as Bin import Foreign (Int16) signalToBinaryPut :: [Int16] -> B.ByteString signalToBinaryPut = Bin.runPut . mapM_ (Bin.putWord16host . fromIntegral) writeSignalBinaryPut :: FilePath -> [Int16] -> IO () writeSignalBinaryPut fileName = B.writeFile fileName . signalToBinaryPut measureTime :: String -> IO () -> IO () measureTime name act = do putStr (name++": ") timeA <- getClockTime act timeB <- getClockTime let td = diffClockTimes timeB timeA print (fromIntegral (tdSec td) + fromInteger (tdPicosec td) * 1e-12 :: Double) numSamples :: Int numSamples = 1000000 zeroSignal16 :: [Int16] zeroSignal16 = replicate numSamples 0 zeroByteString :: B.ByteString zeroByteString = B.replicate (fromIntegral (2 * numSamples)) 0 main :: IO () main = do measureTime "write zero bytestring" (B.writeFile "zero-bytestring.sw" zeroByteString) measureTime "put zero int16" (writeSignalBinaryPut "zero-int16string.sw" zeroSignal16) The program is compiled with GHC-6.4 and option -O2, CPU clock 1.7 GHz. This yields: $ speedtest write zero bytestring: 2.5674e-2 put zero int16: 1.080541 That is, not using ByteString.replicate and converting from [Int16] to ByteString slows down computation by a factor of 40. What am I doing wrong?

3 4

Re: [Haskell-cafe] IDE?
by Andrew Coppin 19 Jun '07

19 Jun '07

Mark T.B. Carroll wrote: > Are KWrite and Kate something to do with KDE or something? One of the > first things I do with a new Linux install is to dump all the KDE and > Gnome stuff on the basis that it's an enormous amount of bloatware for > little gain. Others may think differently! (-: > Yeah, that'll be it then. ;-) Gnome and KDE are both rather bloated... Unfortunately, nothing better exists. :-( But then, the entire Linux world is too messy for me... hence my request for a petter OS.

4 4

Announce: New York Functional Programmers Meetup
by Brian Hurt 19 Jun '07

19 Jun '07

I'd like to announe the New York Functional Programmers Meetup, which is Wednesday, June 27th, 7PM, at the offices of Jane Street Capital. The NYFP meetup is for people using or interested in strongly typed functional languages, such as Haskell, Ocaml, SML, etc. Meeting details are here: http://lisp.meetup.com/59/ (sorry about the Lisp category- it's the closest thing Meetup has to "Functional Programmers"). Brian

1 0

Re: [Haskell-cafe] IDE?
by Michael T. Richter 19 Jun '07

19 Jun '07

On Sun, 2007-17-06 at 20:27 -0300, Alex Queiroz wrote: > Albeit buttons are mostly a waste of time because the keyboard is > so much more powerful, For a very small percentage of users, yes. For the vast majority, not even close. > nice and beautiful fonts are really a must. > Fortunately Emacs have them, as the attached screenshot demonstrates. Screenshots are worthless if they don't match my screen, aren't they? I guess I can open up exactly the same file that's in your screenshot and then use your screenshot as a background to my screen so I have the illusion of decent fonts, but that's not exactly a productive environment now, is it? -- Michael T. Richter <ttmrichter(a)gmail.com> (GoogleTalk: ttmrichter(a)gmail.com) Experts in advanced countries underestimate by a factor of two to four the ability of people in underdeveloped countries to do anything technical. (Charles P Issawi)

6 6

Re: [Haskell-cafe] IDE?
by Andrew Coppin 19 Jun '07

19 Jun '07

Mark T.B. Carroll wrote: > Andrew Coppin <andrewcoppin(a)btinternet.com> writes: > (snip) > >> KWrite and/or Kate are almost always installed when you play with >> somebody's Linux box. Emacs virtually never is. >> > (snip) > > Hmmmm. Exactly the opposite seems to be true on mine. (-: > Really? Mmm... perhaps it's distro-specific or something. *shrugs*

1 0

drscheme as haskell IDE?
by Vikrant 18 Jun '07

18 Jun '07

Hi, I see that drscheme has support for various dialects of lisps. It also supports algol! is it possible to add support for haskell in drscheme? or is there any IDE like drscheme for haskell? == Vikrant

1 0

Re: [Haskell-cafe] IDE?
by Donnchadh Ó Donnabháin 18 Jun '07

18 Jun '07

Hi Peter, I'm also just starting to learn Haskell and tried the eclipsefp eclipse plugin [1] (since my day job is java development). It seems a little basic at the moment, but judging from this blog [2] it seems to have a lot of potential. In fact part of the project seems to be to allow the development of eclipse plugins written in haskell, which could allow the possibility of integrating some of the tools listed on the haskell wiki with it. I also tried eclipsedarcs [3] for darcs repository access but it only really seems to work with local repositories. Donnchadh [1] http://eclipsefp.sourceforge.net/haskell/index.html [2] http://cohatoe.blogspot.com/ [3] http://eclipsedarcs.org/doku.php

2 2

Sneaking haskell in the workplace -- cleaning csv files
by Jim Burton 18 Jun '07

18 Jun '07

I need to remove newlines from csv files (within columns, not at the end of entire lines). This is prior to importing into a database and was being done at my workplace by a java class for quite a while until the files processed got bigger and it proved to be too slow. (The files are up to ~250MB at the moment) It was rewritten in PL/SQL, to run after the import, which was an improvement, but it still has our creaky db server thrashing away. (You may have lots of helpful suggestions in mind, but we can't clean the data at source and AFAIK we can't do it incrementally because there is no timestamp or anything on the last change to a row from the legacy db.) We don't need a general solution - if a line ends with a delimiter we can be sure it's the end of the entire line because that's the way the csv files are generated. I had a quick go with ByteString (with no attempt at robustness etc) and although I haven't compared it properly it seems faster than what we have now. But you can easily make it faster, surely! Hints for improvement please (e.g. can I unbox anything, make anything strict, or is that handled by ByteString, is there a more efficient library function to replace the fold...?). module Main where import System.Environment (getArgs) import qualified Data.ByteString.Char8 as B --remove newlines in the middle of 'columns' clean :: Char -> [B.ByteString] -> [B.ByteString] clean d = foldr (\x ys -> if B.null x || B.last x == d then x:ys else (B.append x $ head ys):(tail ys)) [] main = do args <- getArgs if length args < 2 then putStrLn "Usage: crunchFile INFILE OUTFILE [DELIM]" else do bs <- B.readFile (args!!0) let d = if length args == 3 then head (args!!2) else '"' B.writeFile (args!!1) $ (B.unlines . clean d . B.lines) bs Thanks, Jim -- View this message in context: http://www.nabble.com/Sneaking-haskell-in-the-workplace----cleaning-csv-fil… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

7 19

dangerous inlinePerformIO in Data.Binary(?)
by Udo Stenzel 18 Jun '07

18 Jun '07

Greetings, I was trying to understand the magic inside Data.Binary, and found two somewhat suspicious uses of inlinePerformIO, which imho has a far too innocuous name: | toLazyByteString :: Builder -> L.ByteString | toLazyByteString m = S.LPS $ inlinePerformIO $ do | buf <- newBuffer defaultSize | return (runBuilder (m `append` flush) (const []) buf) Why is this safe? Considering the GHC implementation of IO, isn't there a real danger that 'newBuffer defaultSize' is floated out and therefore every invocation of 'toLazyByteString' starts out with the same buffer? Isn't that exactly the reason why unsafePerformIO and runST are declared NOINLINE? The other occurence is: | unsafeLiftIO :: (Buffer -> IO Buffer) -> Builder | unsafeLiftIO f = Builder $ \ k buf -> inlinePerformIO $ do | buf' <- f buf | return (k buf') which might be safe, since 'f buf' cannot float out of the lambda which binds 'buf', but still, all this stuff is inlined, something constant might get plugged in the place of buf and the result might be floated out to give us an even harder to find Heisenbug. Am I missing something and this is actually safe? If not, what can be done to avoid such errors? I'd really hate to find building blocks that crumble under pressure in standard libraries... -Udo

4 5

How to read -ddump-hi output (and other phases) from GHC
by Alistair Bayley 18 Jun '07

18 Jun '07

I'm collecting links to documents describing some of GHC's optimisation output flags, like -ddump-hi and -ddump-simpl. I'll add stuff to this wiki page: http://www.haskell.org/haskellwiki/Performance/GHC So far I've found little bits in the GHC manual, like: 4.16.3. How to read Core syntax http://www.haskell.org/ghc/docs/latest/html/users_guide/options-debugging.h… (and the Encoding module has the actual rules for the Unique names) http://darcs.haskell.org/ghc/compiler/utils/Encoding.hs 6.2. Faster: producing a program that runs quicker http://www.haskell.org/ghc/docs/latest/html/users_guide/faster.html (see "How do I find out a function's strictness?") Any other hints? Alistair

5 4

Re: Yaham - Yet Another HAskell Mode for GNU Emacs
by Pete Kazmier 17 Jun '07

17 Jun '07

Ian Zimmerman <itz(a)madbat.mine.nu> writes: > It has a different focus than the Moss haskell-mode that's normally > used nowadays. Yaham strives, first and foremost, to integrate well > with the rest of Emacs and respect the Emacs ecosystem. Could you elaborate on this? Perhaps an itemized list of things that are different? Thanks, Pete

1 0

lists with mixed types
by Anatoly Yakovenko 17 Jun '07

17 Jun '07

If I define something like this: data Bar = Bi Int | Bf String deriving Show data Foo = Fi Int | Fs Float deriving Show func::Foo -> Bar func (Fi xx) = Bi xx func (Fs ff) = Bf (show ff) I can do: > map func [(Fi 1), (Fs 2.0)] [Bi 1,Bf "2.0"] but what i really want to do is just do map func [1, 2.0] [1, "2.0"] I understand that this is impossible in haskell, but why cant the compiler generate the Foo and Bar data types for me and just require that i have a func defined for Int -> Int and Float -> String?

2 1

Xlib: problem creating a window with override_redirect set
by Andrea Rossato 17 Jun '07

17 Jun '07

Hi, I'm trying, without success, to create a window with the attribute override_redirect set to True (this way the window manager should not take care of it). Obviously with Xlib (X11-1.2.2). No meter how I try I seem not to be able to get there. In test1 I try with the correct method (createWindow), but I get an error message: X Error of failed request: BadMatch (invalid parameter attributes) Major opcode of failed request: 1 (X_CreateWindow) Serial number of failed request: 7 Current serial number in output stream: 9 With test2 I can open the window, but I'm not able to set that attribute. Any help would be greatly appreciated. TIA. Andrea the example code: module Main where import Graphics.X11.Xlib import Graphics.X11.Xlib.Misc import Graphics.X11.Xlib.Extras import Control.Concurrent import Data.Bits main = test2 test1 = do dpy <- openDisplay "" let dflt = defaultScreen dpy rootw <- rootWindow dpy dflt win <- mkWindow dpy (defaultScreenOfDisplay dpy) rootw 0 0 100 100 mapWindow dpy win sync dpy True threadDelay $ 2 * 1000000 mkWindow dpy scr rw x y h w = do let attrmask = cWOverrideRedirect visual = defaultVisualOfScreen scr attributes <- allocaSetWindowAttributes (\s -> return $ s ) set_override_redirect attributes True window <- createWindow dpy rw x y -- x, y w h -- width, height 1 -- border_width 1 inputOutput visual attrmask attributes putStrLn "Done!" return window test2 = do dpy <- openDisplay "" let dflt = defaultScreen dpy rootw <- rootWindow dpy dflt win <- createSimpleWindow dpy rootw 0 0 100 100 1 0x000000 0xFFFFFF mapWindow dpy win sync dpy True threadDelay $ 2 * 1000000 wa <- getWindowAttributes dpy win allocaXEvent $ \ev -> do setEventType ev configureNotify setConfigureEvent ev win win 100 100 20 20 1 win True sendEvent dpy win False cWOverrideRedirect ev --nextEvent dpy ev getEvent ev sync dpy True a <- getWindowAttributes dpy win putStrLn $ show (wa_override_redirect a)

1 2

Darcs on Solaris x86
by Rich Collins 17 Jun '07

17 Jun '07

I was able to install the ghc binary for solaris x86, but darcs fails on configure: configure:2718: ghc -o conftest conftest.hs ld: fatal: symbol `GHC_ZCCReturnable_static_info' in file /opt/local/ lib/ghc-6.6.1/libHSrts.a(PrimOps.o): section [1] .text: size 8212: symbol (address 0x2014, size 4) lies o utside of containing section ld: fatal: library -lgmp: not found ld: fatal: File processing errors. No output written to conftest collect2: ld returned 1 exit status

3 3

embedded build language?
by Greg Fitzgerald 17 Jun '07

17 Jun '07

Has anyone embedded a build language in Haskell? Something like Rake<http://rake.rubyforge.org/>is to Ruby, but in Haskell or any statically-typed functional language. Thanks, Greg

3 4

Literate Priority Queue, plus question
by Michael T. Richter 16 Jun '07

16 Jun '07

I'm trying my hand at making an improved, more efficient, Sieve of Eratosthenes implementation based on Melissa O'Neil's paper (http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf) to augment the inefficient not-Sieve I've documented at http://en.literateprograms.org/Sieve_of_Eratosthenes_(Haskell). To get the most efficient version that she outlines in her paper, I've had to implement a priority queue. Being a lazy^Wsmart programmer, I hunted for an implementation of a priority queue and found one at http://www.haskell.org/haskellwiki/Haskell_Quiz/Astar/Solution_Dolio which I promptly nicked and modified to suit the interface Melissa's code requires. I then documented it exhaustively. The output of this can be found at http://en.literateprograms.org/Priority_Queue_(Haskell). (I'd appreciate any vetting people could make -- I did some minimal testing of my own, but some more experienced eyes will likely spot edge cases I'm not able to at this point.) The vetting, however, isn't my main point. My main point is the priority queue as found on the Haskell Wiki. While I was explaining the code of my priority queue, I spotted something odd: although the queue is structured, essentially, as a binary tree (Branch key value leftNode rightNode), I could see no operations at all that ever put anything in the right node. Ever. At all. Thinking this was because of the weird interface I put on the priority queue, I went back to look at the place I stole it from. There, too, I could see no operations at all that put anything into the right node. This bothers me a bit (to put it mildly) because it seems I'm carrying around this one data element that's perpetually set to "Nil" and that I'm basically now having my "priority queue" devolve, in effect, into a sorted list. Am I missing something obvious? If so, what is it? If not, should I just bite the bullet and change my priority queue implementation into a sorted list or is there a way to actually use a binary tree there? -- Michael T. Richter <ttmrichter(a)gmail.com> (GoogleTalk: ttmrichter(a)gmail.com) Theory is knowledge that doesn't work. Practice is when everything works and you don't know why. (Hermann Hesse)

4 3

Haskell record extension?
by bf3＠telenet.be 16 Jun '07

16 Jun '07

I'm learning Haskell. I was surprised that the following example did not compile: data Vector2 = Vector2 { x :: Float, y :: Float } data Vector3 = Vector3 { x :: Float, y :: Float, z :: Float } error: "Multiple declarations of `Main.x'" This seems to be a known issue and if I understand it correctly it has to do with the fact that Haskell does not support function general overloading ala C++. One either has to use type classes, or put each record in a separate module and fiddle with the qualified namespaces. I read multiple papers with proposals to fix this, but does GHC implement any of these? Thanks, Peter

5 6

Re: [Haskell-cafe] Memo + IORef
by David House 16 Jun '07

16 Jun '07

Tony Morris writes: > Yes, but where does the IORef live? Wouldn't I have to pass it back and > forth between invocations? If not, where do I get the IORef from on > subsequent invocations? Got a short example? That's where the unsafePerformIO comes in. With unsafePerformIO and IORefs, you can have global mutable variables: {-# NOINLINE #-} memo :: IORef Int memo = unsafePerformIO (newIORef Nothing) f = unsafePerformIO $ do ref <- readIORef memo case ref of Just val -> return val Nothing -> let val = complexCalculation in writeIORef memo val >> return val Something like that. If f took an argument then you'd probably use a IORef Map or IORef IntMap or something in place of IORef Int. Be careful to: 1) Not break referential transparency. I.e. in my example, f will always return the same value, how ever many times you call it. It's possible to break this property using this trick. 2) Not use polymorphic references, as they lead to type unsafety [1]. 3) Always use the {-# NOINLINE #-} pragma on any IORefs you create this way. [1]: http://haskell.org/ghc/docs/latest/html/libraries/base/System-IO-Unsafe.htm… -- -David House, dmhouse(a)gmail.com

1 0

Memo + IORef
by Tony Morris 16 Jun '07

16 Jun '07

I was told on #haskell (IRC) the other day that it is possible to write a general memoisation table using IORef and unsafePerformIO. I can't think of how this can be achieved without writing to a file, since a function cannot hold state between invocations. What am I missing? -- Tony Morris http://tmorris.net/

2 1

Template haskell problem
by Marc Weber 16 Jun '07

16 Jun '07

I want to write a a template haskell function deriving show for data types without constructor. -- example -- data A a -- the derived instance: -- instance (Show a) => Show (A a) where -- show _ = "A " ++ show (undefined :: a) deriveShowNoConstructors :: Name -> Q [ Dec ] deriveShowNoConstructors name = do TyConI (DataD [] _ typeParams [] []) <- reify name runIO $ putStrLn $ show typeParams runIO $ hFlush stdout return [ InstanceD (contexts typeParams) (AppT (ConT nShow) (iOf (ConT name) typeParams)) [ FunD (mkName "show") [Clause [WildP] (NormalB (foldr (\a n -> InfixE (Just a) (VarE (mkName "++")) (Just n)) (LitE (StringL (pprint name))) (map und typeParams))) -- <<< replacing occurs here (see below) [] ] ] ] where contexts = map (\n -> AppT (ConT nShow) (VarT n) ) -- ( ... ) => iOf = foldr (\n a -> AppT a (VarT n) ) -- ( ... ) where nShow = mkName "Show" und n = AppE (VarE (mkName "show")) (SigE (VarE (mkName "undefined")) (ForallT [n] [] (VarT n))) -- undefined :: typePara But when trying to run it with: data A a b c [ .. module change ] $( do l <- deriveShowNoConstructors ''A runIO $ putStrLn $ pprint l runIO $ hFlush stdout return l ) I get the error: src-HListMissing/HListMissingTest.hs|29| 3: || Ambiguous type variable `a[ad8]' in the constraint: || `Show a[ad8]' || arising from use of `show' || at src-HListMissing/HListMissingTest.hs:(29,3)-(32,13) || Probable fix: add a type signature that fixes these type variable(s) || src-HListMissing/HListMissingTest.hs|29| 3: || Ambiguous type variable `b[ada]' in the constraint: || `Show b[ada]' || arising from use of `show' || at src-HListMissing/HListMissingTest.hs:(29,3)-(32,13) || Probable fix: add a type signature that fixes these type variable(s) || src-HListMissing/HListMissingTest.hs|29| 3: || Ambiguous type variable `c[adc]' in the constraint: || `Show c[adc]' || arising from use of `show' || at src-HListMissing/HListMissingTest.hs:(29,3)-(32,13) || Probable fix: add a type signature that fixes these type variable(s) When replacing typeParams with [] (thus only show _ = "Class" instead of show _ = "Class" ++ (undefined:: a) ++ ... it compiles and prints the pretty printed abstract syntax tree as expected: || instance (Show a_0, Show b_1, Show c_2) => Show (THStuff.A c_2 || b_1 || a_0) || where show _ = "THStuff.A" Do you see what I am doing wrong? The function und :: Name -> Exp und n = AppE (VarE (mkName "show")) (SigE (VarE (mkName "undefined")) (ForallT [n] [] (VarT n))) should create the (show $ undefined :: a) part. Marc Weber

1 1

lists with mixed types
by oleg＠pobox.com 16 Jun '07

16 Jun '07

Anatoly Yakovenko wrote: > but what i really want to do is just do > map func [1, 2.0] > [1, "2.0"] > > I understand that this is impossible in haskell, If you use a heterogeneous list, it is possible. The HList paper describes such examples. http://homepages.cwi.nl/~ralf/HList/ > but why cant the > compiler generate the Foo and Bar data types for me and just require > that i have a func defined for Int -> Int and Float -> String? It can. One can write something like lst = (1::Int) `eCons` True `eCons` 'a' `eCons` eNil the result is a true Haskell list of the type [Either Int (Either Bool Char)] and the contents [Left 1, Right (Left True), Right (Right 'a')] Haskell figures out the union (Either) type automatically. Using a function like hOccurs one can `downcast' from that union type to a specific type (Int or Char) so one does not need to care about the number and amount of Left and Right... In more detail, this is described in Section 5.5 of http://homepages.cwi.nl/~ralf/OOHaskell and code at http://darcs.haskell.org/OOHaskell/ShapesEither.hs

1 0

Re: [Haskell-cafe] Sneaking haskell in the workplace -- cleaning csv files
by Donn Cave 16 Jun '07

16 Jun '07

Quoth Tomasz Zielonka <tomasz.zielonka(a)gmail.com>: | On Fri, Jun 15, 2007 at 11:31:36PM +0100, Jim Burton wrote: | > I think that would only work if there was one column per line...I didn't | > make it clear that as well as being comma separated, the delimiter is | > around each column, of which there are several on a line so if the | > delimiter is ~ a file might look like: | > | > ~sdlkfj~, ~dsdkjf~ #eo row1 | > ~sdf | > dfkj~, ~dfsd~ #eo row 2 | | It would be easier to experiment if you could provide us with an | example input file. If you are worried about revealing sensitive | information, you can change all characters other then newline, | ~ and , to "A"s, for example. An accompanying output file, for checking | correctness, would be even nicer. Yes, especially if there's anyone else as little acquainted with CSV files as I am! I have never bothered to learn to work with multiple lines in sed, but from what I gather so far, the following awk would do it -- awk '{ if (/~$/) print; else printf "%s", $0 }' (literal separator for legibility.) I know we're not exactly looking for an awk or sed solution here, but thought it might add some context to the exercise anyway. Donn Cave, donn(a)drizzle.com

1 0

This is an interesting place to showcase Haskell.
by Michael T. Richter 16 Jun '07

16 Jun '07

http://en.literateprograms.org/LiteratePrograms:Welcome There's some Haskell there already, but I think a lot more could be shown there. Even code dumps of things would be nice. They can always be explained later. -- Michael T. Richter <ttmrichter(a)gmail.com> (GoogleTalk: ttmrichter(a)gmail.com) Never, ever, ever let systems-level engineers do human interaction design unless they have displayed a proven secondary talent in that area. Their opinion of what represents good human-computer interaction tends to be a bit off-track. (Bruce Tognazzini)

2 4

GHCI hangs on Gtk2HS SOE on Windows, but GHC works fine?
by bf3＠telenet.be 16 Jun '07

16 Jun '07

I'm learning Haskell using Paul Hudak's book SOE. I'm using GHC 6.6 under Windows XP. GHC on Windows does not seem to come with HGL (is this correct?), so I used Gtk2HS, which contains a SOE implementation. I noticed that most programs hang when using GHCI, but they work fine with GHC. For example, the following mini program: import Graphics.SOE.Gtk main = runGraphics (openWindow "Stuck" (300,300) >>= closeWindow) completely hangs GHCI when running 'main', but using the GHC-created executable, a window correctly pops up and closes immediately, nicely returning to the command prompt. As GHCI is easier for experimenting, it would be nice if this worked. Thanks, Peter

2 1

Construct all possible trees
by Andrew Coppin 16 Jun '07

16 Jun '07

Well, I eventually came up with this: --------------------------------- data Tree = Leaf Int | Branch Tree Tree deriving Show pick :: [x] -> [(x,[x])] pick = pick_from [] pick_from :: [x] -> [x] -> [(x,[x])] pick_from ks [] = [] pick_from ks xs = (head xs, ks ++ tail xs) : pick_from (ks ++ [head xs]) (tail xs) trees :: [Int] -> [Tree] trees = map fst . (\ts -> all_trees 1 (2 * length ts) ts) . map Leaf all_trees :: Int -> Int -> [Tree] -> [(Tree,[Tree])] all_trees n m ts | n > m = [] | otherwise = pick ts ++ sub_trees n m ts sub_trees :: Int -> Int -> [Tree] -> [(Tree,[Tree])] sub_trees n m ts = do let n2 = n * 2 (t0,ts0) <- all_trees n2 m ts (t1,ts1) <- all_trees n2 m ts0 return (Branch t0 t1, ts1) ----------------------------- For example, trees [1,2,3] now gives Leaf 1 Leaf 2 Leaf 3 Branch (Leaf 1) (Leaf 2) Branch (Leaf 1) (Leaf 3) Branch (Leaf 1) (Branch (Leaf 2) (Leaf 3)) Branch (Leaf 1) (Branch (Leaf 3) (Leaf 2)) Branch (Leaf 2) (Leaf 1) Branch (Leaf 2) (Leaf 3) Branch (Leaf 2) (Branch (Leaf 1) (Leaf 3)) Branch (Leaf 2) (Branch (Leaf 3) (Leaf 1)) Branch (Leaf 3) (Leaf 1) Branch (Leaf 3) (Leaf 2) Branch (Leaf 3) (Branch (Leaf 1) (Leaf 2)) Branch (Leaf 3) (Branch (Leaf 2) (Leaf 1)) Branch (Branch (Leaf 1) (Leaf 2)) (Leaf 3) Branch (Branch (Leaf 1) (Leaf 3)) (Leaf 2) Branch (Branch (Leaf 2) (Leaf 1)) (Leaf 3) Branch (Branch (Leaf 2) (Leaf 3)) (Leaf 1) Branch (Branch (Leaf 3) (Leaf 1)) (Leaf 2) Branch (Branch (Leaf 3) (Leaf 2)) (Leaf 1) which looks pretty comprehensive to me! The derivation wasn't easy. It goes something like this: First, the "pick" function takes a list and picks a single element from it, returning the element picked and the remaining unpicked elements. It does this inside the list monad, thus representing every possibel choice. (It's defined in terms of pick_from, which isn't used anywhere else. The algorithm should be fairly self-evident.) Next, we have "trees" which transforms a list of integers into a list of trivial 1-leaf trees to be processed by "all_trees". The "all_trees" function calls pick to select all possible trivial trees, and then calls "sub_trees" to pick all possible nontrivial trees. The code for sub_trees would go something like this: sub_trees ts = do t0 <- ts t1 <- ts return (Branch t0 t1) But now t0 == t1 sometimes, which we cannot allow. Hence the "pick" function: sub_trees ts = do (t0,ts0) <- pick ts (t1,ts1) <- pick ts0 return (Branch t0 t1, ts1) And now the problem is solved. However, this only generates all possible 2-leaf trees. To make *all* possible trees, we must be recursive: sub_trees ts = do (t0,ts0) <- all_trees ts (t1,ts1) <- all_trees ts0 return (Branch t0 t1, ts1) And now it works properly. Er... wait. Now we have an infinite recursive loop! all_trees --> sub_trees --> all_trees (with the same arguments)! The only way I could figure out to avoid that is to count how big the input list is - and hence how deep the tree can possibly be. Then you keep track of how deep you are, and abort when you get too deep. I added lots of hackery to avoid recomputing stuff. Makes the code look very messy and ugly...

1 2

ICFP07 Accepted Papers
by Matthew Fluet (ICFP Publicity Chair) 15 Jun '07

15 Jun '07

Accepted Papers ICFP 2007: International Conference on Functional Programming http://www.informatik.uni-bonn.de/~ralf/icfp07.html Freiburg, Germany, 1-3 October 2007 The ICFP 2007 Program Chair and Committee are pleased to announce that the following papers have been accepted for the conference. Additional information regarding the final program, invited speakers, and registration will be forthcoming. However, the Local Arrangements Chair offers the following advice regarding hotel reservations: * As September and October is Freiburg's main tourist season, it is important that participants book hotel rooms early. The blocks of hotel rooms reserved for ICFP participants will be held until August 1. It is expected that many downtown hotels will be fully booked at the time of the conference. [However, there should be little to no penalty for cancelling a hotel room reservation after August 1.] More details regarding accommodation and travel may be obtained from the ICFP 2007 Local Information webpage: http://proglang.informatik.uni-freiburg.de/ICFP2007/ Accepted papers ~~~~~~~~~~~~~~~ A Generic Usage Analysis with Subeffect Qualifiers by Jurriaan Hage, Stefan Holdermans, Arie Middelkoop Experience Report: A Haskell interpreter for CellML by Jonathan Cooper, Steve McKeever A type directed translation of MLF to System-F by Daan Leijen A Type System for Recursive Modules by Derek Dreyer Adding Delimited and Composable Control to a Production Programming Environment by Matthew Flatt, Gang Yu, Robert Bruce Findler, Matthias Felleisen Bidirectionalization Transformation based on Automatic Derivation of View Complement Functions by Kazutaka Matsuda, Zhenjiang Hu, Keisuke Nakano, Makoto Hamana, Masato Takeichi Experience Report: Building an Eclipse-based IDE for Haskell by Leif Frenzel Compiling with Continuations, Continued by Andrew J. Kennedy Constructor specialisation for Haskell programs by Simon Peyton Jones Evaluating High-Level Distributed Language Constructs by Jan Nystrom, Phil Trinder, David King Extensible Pattern Matching via a Lightweight Language Extension by Don Syme, Gregory Neverov, James Margetson Faster laziness using dynamic pointer tagging by Simon Marlow, Alexey Rodriguez, Simon Peyton Jones Feedback Directed Implicit Parallelism by Tim Harris, Satnam Singh Finger Trees in Russell by Matthieu Sozeau Functional Pearl: The Great Escape by David Herman Experience Report: Functional Programming in C-Rules by Jeremy Wazny Inductive Reasoning about Effectful Data Types by Andrzej Filinski, Kristian Stoevring iTasks: Executable Specifications of Interactive Work Flow Systems for the Web by Rinus Plasmeijer, Peter Achten, Pieter Koopman Lazy Call-By-Value Evaluation by Frank Huch, Bernd Brassel, Sebastian Fischer, Michael Hanus, German Vidal McErlang: A Model Checker for a Distributed Functional Programming Language by Lars-Åke Fredlund, Hans Svensson On Barron and Strachey's Cartesian Product Function by Michael Spivey, Olivier Danvy Ott: Effective Tool Support for the Working Semanticist by Peter Sewell, Francesco Zappa Nardelli, Scott Owens, Gilles Peskine, Thomas Ridge, Susmit Sarkar, Rok Strnisa Relating Complexity and Precision in Control Flow Analysis by David Van Horn, Harry Mairson Experience Report: Scheme in Commercial Web Application Development by Noel Welsh, David Gurnell Stream Fusion: From Lists to Streams to Nothing at All by Duncan Coutts, Roman Leshchinskiy, Don Stewart Tangible Functional Programming by Conal Elliott Termination Analysis and Call Graph Construction for Higher-Order Functional Programs by Damien Sereni The Portable R6RS Syntax System by Abdulaziz Ghuloum, R. Kent Dybvig Experience Report: The Reactis Validation Tool by Steve Sims, Daniel C. DuVarney Type-safe Higher-order Channels in ML-like Languages by Sungwoo Park User-Friendly Functional Programming for Web Mashups by Rob Ennals, David Gay Experience Report: Using Functional Programming to Manage a Linux Distribution by Clifford Beshers, David Fox, Jeremy Shaw

1 0

Re: [Haskell-cafe] Optimising UTF8-CString -> String marshaling, plus comments on withCStringLen/peekCStringLen
by Alistair Bayley 15 Jun '07

15 Jun '07

> > {- Arity: 4 Strictness: LSSL -} > > Right. Unboxed args are always given the annotation L. So that function > is strict in that pointer arg, but GHC is choosing not to unbox it. I'm > not sure why that's the case. I thought maybe it was because I hadn't said -funbox-strict-fields, but it didn't change when I did. > > Is there some semantic advantage to bang-patterns, or is it just a > > syntactic convenience? > > It's syntactic convenience. I've noticed differences between strictness guards and bang-patterns with GHC. This is a problem, I think, because bang-patterns are GHC only, and I wanted to keep the code portable. This strictness guard: readUTF8Char :: Int -> Int -> Ptr Word8 -> IO Char readUTF8Char x offset p | () !x !offset !p !False = undefined | otherwise = ... where x ! y = seq x y results in this simplifier output: [Arity 3 Str: DmdType LSS] $wreadUTF8Char_r38I = \ (ww_s30B :: GHC.Prim.Int#) (w_s30D :: GHC.Base.Int) (w1_s30E :: GHC.Ptr.Ptr GHC.Word.Word8) -> However, if I change this to: {-# OPTIONS_GHC -fbang-patterns #-} ... readUTF8Char :: Int -> Int -> Ptr Word8 -> IO Char readUTF8Char !x !offset !p | otherwise = then I get this simpifier output: [Arity 3 Str: DmdType LLL] $wreadUTF8Char_r38n = \ (ww_s2Zk :: GHC.Prim.Int#) (ww1_s2Zo :: GHC.Prim.Int#) (ww2_s2Zs :: GHC.Prim.Addr#) -> Also, with bang-patterns I've noticed that fromUTF8Ptr transforms into two functions, which contain very similar code: [Arity 5] Foreign.C.UTF8.$s$wfromUTF8Ptr = \ (acc_X151 :: GHC.Base.String) (new_s_a2GQ :: GHC.Prim.State# GHC.Prim.RealWorld) (a87_a2GR :: GHC.Base.Char) (ww_s2ZH :: GHC.Prim.Addr#) (sc_s36j :: GHC.Prim.Int#) -> [Arity 4 Str: DmdType LLSL] Foreign.C.UTF8.$wfromUTF8Ptr = \ (ww_s2ZD :: GHC.Prim.Int#) (ww1_s2ZH :: GHC.Prim.Addr#) (w_s2ZJ :: GHC.Base.String) (w1_s2ZK :: GHC.Prim.State# GHC.Prim.RealWorld) -> $wfromUTF8Ptr calls itself and $s$wfromUTF8Ptr, but $s$wfromUTF8Ptr only every calls itself, so $wfromUTF8Ptr could be considered the wrapper, and $s$wfromUTF8Ptr the worker, I guess. AFAICT it's a transformation of the various cases in fromUTF8Ptr: | x <= 0x7F -> fromUTF8Ptr (bytes-1) p (chr x:acc) | x <= 0xBF && bytes == 0 -> error "fromUTF8Ptr: ..." | x <= 0xBF -> fromUTF8Ptr (bytes-1) p acc | otherwise -> do c <- readUTF8Char x bytes p fromUTF8Ptr (bytes-1) p (c:acc) The first case, x <= 0x7F, results in a call to $s$wfromUTF8Ptr. The third case, x <= 0xBF, results in a call to $wfromUTF8Ptr. The last case, otherwise, results in a call to $s$wfromUTF8Ptr. The calls to $s$wfromUTF8Ptr pass the newly constructed Char and the rest of the String separately, and they are cons'ed in $s$wfromUTF8Ptr. Not sure what benefit this gives... I don't know what transformation causes this, but it was a bit of a surprise. Alistair

2 3

Happy, GLR and GHC 6.6
by Iván Pérez Domínguez 15 Jun '07

15 Jun '07

Hi everyone, As we all know, FiniteMap was deprecated, and with GHC-6.6 Data.Map must be used instead. Some function names in Data.Map clash with names in prelude, and Map is usually imported qualified. Happy generates GLR parsers (-l), but the templates it uses keep calling FiniteMap functions. When Data.Map is imported, it's not imported qualified and some function names are ambiguous. I've been using a modified template to generate a GLR parser with GHC-6.6 and it seems to work just fine (there are few changes, not a big deal anyway). I just got the most recent version of Happy and the problem remains, so I applied my changes to GLR_Lib.lhs and ran a diff. The result is attached to this mail. Hope it helps someone else. Cheers, Ivan. PS. I seem to recall having sent this mail months ago. Couldn't find it, though. In case it's been sent twice, I apologise.

2 4

ghc-pkg list says a package is installed, but ghci won't load its exposed module (HDBC-ODBC)
by Thomas Hartman 15 Jun '07

15 Jun '07

ghc-pkg list says a package is installed, but ghci won't load its module (HDBC-ODBC) Any advice? hartthoma@dbnycws28816 ~/haskellInstalls/HDBC-odbc-1.0.1.0 $ ghc-pkg list c:/ghc/ghc-6.6.1\package.conf: Cabal-1.1.6.2, GLUT-2.1.1, HAppS-0.8.4, HDBC-1.0.1, HDBC-odbc-1.0.1.0, HUnit-1.1.1, HaXml-1.13.2, OpenGL-2.2.1, QuickCheck-1.0.1, Win32-2.1.1, base-2.1.1, cgi-3001.1.1, fgl-5.4.1, filepath-1.0, (ghc-6.6.1), haskell-src-1.0.1, haskell98-1.0, html-1.0.1, mtl-1.0.1, network-2.0.1, parsec-2.0, regex-base-0.72, regex-base-0.91, regex-compat-0.71, regex-posix-0.71, regex-tdfa-0.92, rts-1.0, stm-2.0, template-haskell-2.1, time-1.1.1, xhtml-3000.0.2 ..... Prelude> :m + Database.HDBC.ODBC module main:Database.HDBC.ODBC is not loaded ..... $ ghc-pkg.exe describe HDBC-odbc name: HDBC-odbc version: 1.0.1.0 license: LGPL copyright: Copyright (c) 2005-2006 John Goerzen maintainer: John Goerzen <jgoer...@complete.org> stability: Alpha homepage: package-url: description: category: author: exposed: True exposed-modules: Database.HDBC.ODBC hidden-modules: Database.HDBC.ODBC.Connection Database.HDBC.ODBC.Statement Database.HDBC.ODBC.Types Database.HDBC.ODBC.Utils Database.HDBC.ODBC.TypeConv import-dirs: "C:\\Program Files\\Haskell\\HDBC-odbc-1.0.1.0\ \ghc-6.6.1" library-dirs: "C:\\Program Files\\Haskell\\HDBC-odbc-1.0.1.0\ \ghc-6.6.1" hs-libraries: HSHDBC-odbc-1.0.1.0 extra-libraries: odbc32 extra-ghci-libraries: include-dirs: "C:\\Program Files\\Haskell\\HDBC-odbc-1.0.1.0\ \ghc-6.6.1\\include " includes: depends: base-2.1.1 mtl-1.0.1 HDBC-1.0.1 parsec-2.0 hugs-options: cc-options: ld-options: framework-dirs: frameworks: haddock-interfaces: "C:\\Program Files\\Common Files\\HDBC- odbc-1.0.1.0\\doc\\ht ml\\HDBC-odbc.haddock" haddock-html: "C:\\Program Files\\Common Files\\HDBC-odbc-1.0.1.0\\doc\ \html" --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

3 2

Updated urlcheck
by Lutz Donnerhacke 15 Jun '07

15 Jun '07

I'm proud to announce an updated version of dons' concurrent urlcheck. It's a bad and buggy rewrite from scratch. It can check a file of urls or the consistency of the transitive hull of a website incl. the existance of the border urls. Futhermore the warnings from TagSoup parsing can be reported. Main bugs are memory leaks in conjunction with unnecessary retrieval of binary files, and missing documentation. If somebody has enough time in the next weeks: Many thanks in advance. URL: http://www.iks-jena.de/mitarb/lutz/haskell/urlcheck-0.0.tar.gz

2 1

How to devide matrix into small blocks
by L.Guo 15 Jun '07

15 Jun '07

Hi all: I already have one matrix of type [[a]] to store one image. What I want to do is to devide the image into severial small blocks in same size. To do that, I wrote this tool function. chop :: Int -> [a] -> [[a]] chop _ [] = [] chop n ls = take n ls : chop n (drop n ls) But I do not know how to use it to write the function. Thanks for any advice. Regards -------------- L.Guo 2007-06-13

4 11

GTK2HS
by Andrew Coppin 15 Jun '07

15 Jun '07

Erm... wuh? I just tried to install Gtk2hs and got an error message to the effect that it cannot be installed since I have GHC 6.6.1, which isn't 6.6 or 6.4. Anybody know how to fix this? Am I being dumb? Thanks. Andrew.

3 3

found monad in a comic
by Marc A. Ziegert 15 Jun '07

15 Jun '07

<http://xkcd.com/c248.html> ( join /= coreturn ) IMHO this could be a beautiful and easy way to explain monads. comments? - marc

7 8

Implementing Mathematica
by Jon Harrop 15 Jun '07

15 Jun '07

I only just subscribed to this mailing list and I am a complete Haskell newbie, so forgive me if this is too OT. I noticed a recent thread about writing a Mathematica implementation in Haskell. I think this is an excellent idea and would be a great project for a Haskell newbie. I wrote a toy Mathematica implementation in OCaml while I waited to be viva'd for my PhD. It garnered so much interest that Wolfram Research bought it from me for £4,500 and gave me several free copies of Mathematica. Regarding the specific points made: 1. Numerical libraries: you should be able to reuse existing libraries like GMP, BLAS, LAPACK, FFTW and so on. These are often much faster than Mathematica's. For example, FFTW was about 4x faster than Mathematica's FFT the last time I benchmarked it. However, they do not support interval arithmetic. 2. GUI: I would take our existing vector graphics software: http://www.ffconsultancy.com/products/smoke_vector_graphics/ http://www.ffconsultancy.com/products/fsharp_for_visualization/ and rewrite it in Haskell as the foundation. This would far exceed anything that Mathematica has to offer, in part because Mathematica's graphics are still evaluated via the completely generic rewrite engine which is extremely slow. Our code already implements high-performance hardware-accelerated vector graphics and it is probably one of the first things I would consider porting to Haskell (if there is any commercial interest in such a library). 3. The language: the hardest part of reimplementing Mathematica is inferring what it means (there are no formal evaluation semantics). Once you've done that it is just a case of implementing an extensible term rewriter and putting in about 20 core rules. The pattern matcher is well under 100 LOC and you can do various things to make it more efficient. There are two tricks that vastly improve performance of the rewriter: return physically identical results whenever possible, and perform substitution and evaluation at the same time rather than as two separate passes. 4. Libraries: You should have no trouble exceeding the capabilities of Mathematica by pulling in existing libraries. For example, Mathematica provides no wavelet transforms, no time-frequency transforms, no function minimization over an arbitrary number of variables etc. Having worked in numerical computing for many years, I can say that Mathematica is an excellent tool for prototyping and for doing disposable analyses but many people reach for conventional languages when Mathematica's capabilities run dry. You should easily be able to implement a rewriter for the language that is ten times faster and doesn't leak. Incidentally, my implementation of Mathematica in OCaml took four days, and it was one of my first OCaml programs. -- Dr Jon D Harrop, Flying Frog Consultancy Ltd. OCaml for Scientists http://www.ffconsultancy.com/products/ocaml_for_scientists/?e

17 32

FunPtr stability - suggested clarification to FFI Addendum
by Claude Heiland-Allen 15 Jun '07

15 Jun '07

Hi, I think the FFI Addendum should make explicit that FunPtr values are stable (in the sense of StablePtr). I'm writing a Haskell plugin for an application written in C, and the control flow is: C->Haskell->C ; C->Haskell->C ; ... and I was confused by this statement in section 4.1 of the Addendum (under the subheading "Dynamic wrapper"): --8<-- The stub factory mkCallback turns any Haskell computation of type IO () into a C function pointer that can be passed to C routines, which can call back into the Haskell context by invoking the referenced function. --8<-- The usage of "call back" makes it clear that this control flow is ok: Haskell->C->Haskell but I wasn't sure whether the C code could store the pointer and call it later. Apparently it is safe, but it isn't made explicit in the Addendum. As SamB said in #haskell: --8<-- The fact that there is something called "freeHaskellFunPtr" seems to indicate that, yes, those things are stable. It would be totally bonkers to have a "free" function if the associated memory was not stable (and, therefor, garbage collected). --8<-- Thanks for your attention, Claude -- http://claudiusmaximus.goto10.org

1 0

Thread blocked indefinitely problem when playing with signals and MVar on Windows
by Olivier Boudry 15 Jun '07

15 Jun '07

Hi all, I'm playing with signal handlers on Win32. I found a good post on signal handlers but it works with System.Posix.Signals which on Win32 is empty. Blog is here: http://therning.org/magnus/archives/285 I tried to adapt this code to GHC.ConsoleHandler, the Win32 counterpart of System.Posix.Signals. The code: ===================================== module Main where --import System.Posix.Signals import GHC.ConsoleHandler import Control.Concurrent import Control.Concurrent.MVar import System -- ControlC increments counter handler :: MVar (Int, Bool) -> ConsoleEvent -> IO () handler mi ControlC = do (i, exit) <- takeMVar mi putStrLn "In ControlC handler" putMVar mi ((i + 1), False) -- Break sets Bool to True to stop application handler mi Break = do (i, exit) <- takeMVar mi putStrLn "In Break handler" putMVar mi (i, True) -- Ignore other signals handler _ _ = do return () doNothing :: MVar (Int, Bool) -> IO () doNothing mi = do threadDelay 1000000 (i, exit) <- takeMVar mi if exit then do putStrLn "Good bye!" exitWith ExitSuccess else do putStrLn $ "Repeating " ++ (show i) main :: IO () main = do mi <- newMVar (0, False) installHandler (Catch $ handler mi) sequence_ $ repeat $ doNothing mi ===================================== It compiles but when run I receive this: Repeating 0 SignalsText.exe: <<loop>> First iteration is executed but then it gets trapped in what looks like a dead lock. If I remove the installation of the signal handler to just have an infinite loop (comment out installHandler ...) I get this: Repeating 0 SignalsText.exe: thread blocked indefinitely Without the signal handler the code uses only the main and doNothing function and I can't figure out what causes this to block? Something to do with my use of MVar, but what??? Lazy evaluation? Thanks for any advice, Olivier.

1 1

practicality of typeful programming
by Daniil Elovkov 15 Jun '07

15 Jun '07

Hello folks I've recently asked some questions here about some little type hackery implementing an embedded dsl. But now I wonder if it's worth the effort at all... The thing is enforcing static constraints turns out to be quite time consuming, even for 'reasonble' things. The dsl I'm writing will not primarily be used from Haskell sources, rather more likely be input to the interpreter, and hence dynamic analysis after parsing will occur any way. On the other hand, enforcing them excludes some errors... To give you a flavour, classical example, I could represent expressions simply by 'data Exp' or by 'data Exp a' where a is the type of expression and 4 + "str" is illegal, or by 'data Exp s a' where a is the same and s is an additional property, like some kind of things the expression mentions, and there are restrictions on how Exp s1 and Exp s2 can combine. And s is not otrhogonal with a. There may be more properties. I'd like to hear your thoughts on how practical it is, and to which extent, to use typeful programing for statically enforcing constraints, in real-life applications, where readability and maintainability matter.

1 0

Construct all possible trees
by Andrew Coppin 14 Jun '07

14 Jun '07

I'm trying to construct a function all_trees :: [Int] -> [Tree] such that all_trees [1,2,3] will yield [ Leaf 1, Leaf 2, Leaf 3, Branch (Leaf 1) (Leaf 2), Branch (Leaf 1) (Leaf 3), Branch (Leaf 2) (Leaf 1), Branch (Leaf 2) (Leaf 3), Branch (Leaf 3) (Leaf 1), Branch (Leaf 3) (Leaf 2), Branch (Branch (Leaf 1) (Leaf 2)) (Leaf 3), Branch (Branch (Leaf 1) (Leaf 3)) (Leaf 1), Branch (Branch (Leaf 2) (Leaf 1)) (Leaf 3), Branch (Branch (Leaf 2) (Leaf 3)) (Leaf 1), Branch (Branch (Leaf 3) (Leaf 1)) (Leaf 2), Branch (Branch (Leaf 3) (Leaf 2)) (Leaf 1), Branch (Leaf 1) (Branch (Leaf 2) (Leaf 3)), Branch (Leaf 1) (Branch (Leaf 3) (Leaf 2)), Branch (Leaf 2) (Branch (Leaf 1) (Leaf 3)), Branch (Leaf 2) (Branch (Leaf 3) (Leaf 2)), Branch (Leaf 3) (Branch (Leaf 1) (Leaf 2)), Branch (Leaf 3) (Branch (Leaf 2) (Leaf 1)) ] So far I'm not doing too well. Here's what I've got: data Tree = Leaf Int | Branch Tree Tree pick :: [x] -> [(x,[x])] pick = pick_from [] pick_from :: [x] -> [x] -> [(x,[x])] pick_from ks [] = [] pick_from ks [x] = [] pick_from ks xs = (head xs, ks ++ tail xs) : pick_from (ks ++ [head xs]) (tail xs) setup :: [Int] -> [Tree] setup = map Leaf tree2 :: [Tree] -> [Tree] tree2 xs = do (x0,xs0) <- pick xs (x1,xs1) <- pick xs0 return (Branch x0 x1) all_trees ns = (setup ns) ++ (tree2 $ setup ns) Clearly I need another layer of recursion here. (The input list is of arbitrary length.) However, I need to somehow avoid creating duplicate subtrees... (BTW, I'm really impressed with how useful the list monad is for constructing tree2...)

6 14

TorDNSEL
by Tim Newsham 14 Jun '07

14 Jun '07

I wanted to point out: http://exitlist.torproject.org/ written in Haskell. I haven't seen any announcements or info on this list (apologies if someone else mentioned it already). For the record, I'm not affiliated with the project in any way. Tim Newsham http://www.thenewsh.com/~newsham/

2 2

Reading open data types
by Benja Fallenstein 14 Jun '07

14 Jun '07

Hi all, We've had a discussion on #haskell about how we can make a function that reads in serialized values of an open data type, such as class (Show a, Read a) => MyClass a where typeTag :: a -> String ... operations on the open data type... data Obj = forall a. MyClass a => Obj { unObj :: a } We would like to write a function like, oread :: String -> Obj The problem here is that unlike with 'read,' the calling context of 'oread' does not fix the implementation of Read that we want to use. The best we've been able to come up with was to build a table that maps type names to types: type TypeTable = Map String Obj oread :: TypeTable -> String -> Obj oread types s = Obj $ read repr `asTypeOf` unObj (types ! tag) where tag = takeWhile (/= ' ') s repr = drop 1 $ dropWhile (/= ' ') s instance Show Obj where show (Obj x) = typeTag x ++ " " ++ show x As far as we can see, we'll have to create this table manually, without support from the compiler. My suggestion would be to put the code constructing the table for each module at the top of that module, to keep it together with the exports and imports, like this: module Foo.Foo (export1, export2, fooFooTypes) where import Foo.Bar import Foo.Baz import Data.Map fooFooTypes = fooBarTypes `union` fooBazTypes `union` fromList [ ("Foo.Foo.Ty1", Obj (undefined :: Ty1)) , ("Foo.Foo.Ty2", Obj (undefined :: Ty2)) ] However, this is still kind of boring. Is there a better way? If not, would it be a good idea to have compiler support for building this kind of type table? Thanks, - Benja

4 6

Re: [Haskell] Who pays for *.haskell.org machines?
by Bulat Ziganshin 14 Jun '07

14 Jun '07

Hello Malcolm, Wednesday, June 13, 2007, 1:55:43 PM, you wrote: > In addition, we are in the process of setting up a separate server called > code.haskell.org thank you, it's all are great news. some questions: when you plan to make code.haskell.org available? is its funding will be reliable? for example, if we don't get money from Google in 2008 year? i hope that this server will be established as comfortable place for collective work, including wiki, bug tracker, darcs, so on, so on -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

6 5

Redefining Disjunction
by PR Stanley 13 Jun '07

13 Jun '07

Hi Can you think of a fourth way of redefining disjunct using pattern matching? vee :: Bool -> Bool -> Bool vee _ True = True vee True _ = True vee _ _ = False ve :: Bool -> Bool -> Bool ve True True = True ve True False = True ve False True = True ve False False = False v :: Bool -> Bool -> Bool v True b = True v b True = True v b False = b v False b = b Thanks Paul

4 3

Construct all possible trees
by Tom Pledger 13 Jun '07

13 Jun '07

*Andrew Coppin wrote: * | I'm trying to construct a function | | all_trees :: [Int] -> [Tree] | | such that all_trees [1,2,3] will yield : If you write a helper function that takes an N element list, and returns all 2^N ways of dividing those elements into 2 lists, e.g. splits "ab" --> [("ab",""),("b","a"),("a","b"),("","ab")] then you can use it both for dividing the initial list into kept and discarded elements, and for dividing a list between a left subtree and a right subtree. Regards, Tom

2 1

Re: [Haskell] ANNOUNCE: Harpy -- run-time code generation library
by Martin Grabmueller 13 Jun '07

13 Jun '07

[Moved to haskell-cafe] Daniel Mahler schrieb: > Given your reservation regarding LLVM, > you may be interested in vmgen, developed and used as a part of gforth. > It is also claimed that a JVM built with vmgen had performance comparable > to state of the art JITs. > If I remember the author of both gforth (including vmgen) and the > experimantal JVM, > is Anton Ertl. > Personally I have never used it, and do not know how good it is, > so I am not trying to push it. [...] > Anyway as I said, I do not know how much mileage you could get out of it, > but it seemed to be worth mentioning, given what you said about LLVM. Thanks for the pointer to vmgen. From a brief look at the docs and the source code, though, it seems that it supports the generation of threaded interpreters (which are efficient, but not as efficient as real native code) only, whereas we are interested in "real" code generation. Greetings, Martin

1 0

PhD student on Real-life datatype-generic programming
by Johan Jeuring 13 Jun '07

13 Jun '07

=================================================== Vacancy PhD student on Real-life datatype-generic programming Software Technology, Utrecht University, The Netherlands. =================================================== Within the Software Technology group of the Information and Computing Sciences department of Utrecht University there is a vacancy for a PhD student to work on Real-life datatype-generic programming. The position is funded by NWO, the Netherlands Organisation for Scientific Research. ------------------------------------------------------------------------ ----------------- Project summary: Datatype-generic programming has been around for more than 10 years now. We think a lot of progress has been made in the last decade. As an example, there are more than 10 proposals for generic-programming libraries or language extensions just for the lazy functional- programming language Haskell. Although generic programming has been applied in several applications, it lacks users for real-life projects. This is understandable. Developing a large application takes a couple of years, and choosing a particular approach to generic programming for such a project involves a risk. Few approaches that have been developed over the last decade are still supported, and there is a high risk that the chosen approach will not be supported anymore, or that it will change in a backwards-incompatible way in a couple of years time. We propose to create an environment that supports developing real- life applications using generic-programming techniques. We will focus on developing: - a library or a mixture of a library with a language extension for which we will guarantee continuing support. - an example of a real-life application fundamentally using generic- programming techniques. This application will serve as a showcase for generic-programming support for software development and evolution. - generic-programming design patterns. The usage of the generic- programming techniques in real-life projects will exhibit recurrent patterns, and will give valuable advice for and help with developing other applications using generic-programming techniques. Thus we will show how generic programming can be used to develop powerful tools in little time, and that the resulting tools are easy to maintain, adapt, and reuse. ------------------------------------------------------------------------ ----------------- Requirements: Master degree in Computer Science, or equivalent. Good knowledge of functional programming, and several advanced computer science techniques. Knowledge of Haskell, parsing, rewriting, strategies, generic programming, etc. will be useful. Terms of employment: the PhD student should start as soon as possible, but no later than January 1, 2008. The position is for four years (after one year there will be an evaluation), full-time. Gross salary starts with € 1956,-- per month in the first year and increases to € 2502,-- in the fourth year of employment. The salary is supplemented with a holiday bonus of 8% and an end-of-year bonus of 3%. In addition we offer: a pension scheme, partially paid parental leave, facilities for child care, flexible employment conditions in which you may trade salary for vacation days or vice versa. Conditions are based on the Collective Employment Agreement of the Dutch Universities. More information about the project can be found on http:// www.cs.uu.nl/~johanj/publications/nwo-ew2006.pdf More information about the Software Technology group on http:// www.cs.uu.nl/wiki/Center More information about the Information and Computing Sciences department on http://www.cs.uu.nl/ More information about this vacancy can be obtained from Johan Jeuring (johanj(a)cs.uu.nl, http://www.cs.uu.nl/~johanj/, +31 6 40010053). Send your application in pdf (or another non-proprietary format) to SciencePenO(a)uu.nl with a cc to johanj(a)cs.uu.nl. on or before July 31, 2007. We expect to arrange interviews in September. Mention vacancy nr 62712.

1 0

Mathematica
by Andrew Coppin 13 Jun '07

13 Jun '07

Hi folks. How difficult would it be to implement Mathematica in Haskell? I mean, I really like Mathematica, but it costs over £2,000. I can't really afford to pay that much for something that's only really a "toy". (It's not like a *need* it for anything, I just like playing with it.)

10 13

Just curios
by Andrew Coppin 13 Jun '07

13 Jun '07

OK, so this doesn't actually have anything to do with programming in Haskell, but... How in the name of God does a human being end up walking around with a name like "Haskell B. Curry"?

8 9