- Haskell-Cafe - Haskell.org

The "Exp -> Term a" problem (again), how to dynamically create (polymorphic) typed terms in Haskell ??
by Pasqualino 'Titto' Assini 05 Oct '07

05 Oct '07

Hi, I am trying to write an interpreter for a little functional language but I am finding very problematic to dynamically create a typed representations of the language terms. I have googled around and found a few solutions but none seem to solve the problem. This is the example code: > {-# OPTIONS -fglasgow-exts #-} > module Eval where These are my untyped terms (what I get from my parser): > data Exp = EDouble Double | EString String | EPrim String | EApp Exp Exp deriving (Show) And these are the typed terms: > data Term a where > Num :: Double -> Term Double > Str :: String -> Term String > App :: Term (a->b) -> Term a -> Term b > Fun :: (a->b) -> Term (a->b) The problem is to write a function that converts between Exp and Term t as in: > test :: Term Double > test = typecheck $ EApp (EPrim "inc") (EDouble 10.0) So this is the conversion function: > class TypeCheck t where > typecheck :: Exp -> Term t A few primitives: > instance TypeCheck (String->String) where > typecheck (EPrim "rev") = Fun reverse > typecheck (EPrim "show") = Fun show > instance TypeCheck (Double->Double) where > typecheck (EPrim "inc") = Fun ((+1) :: Double -> Double) > instance TypeCheck (Double->String) where > typecheck (EPrim "show") = Fun show > instance TypeCheck Double where > typecheck (EDouble x) = Num x > instance TypeCheck String where > typecheck (EString x) = Str x The problem arises in the conversion of the function application (EApp). It does not seem to be possible to define "typecheck" on EApp in a generic way and is also not possible to distinguish between the different cases: > typecheck (EApp f a) = App (typecheck f :: Term (String->String)) (typecheck a:: Term String) The following pattern overlaps the previous one: > typecheck (EApp f a) = App (typecheck f :: Term (Double->String)) (typecheck a:: Term Double) To avoid this problem I could split my untyped terms in different data types as in: data EDouble = EDouble Double data App a b c = App a b c ... and define TypeCheck separetely on every data type. However, in that case what would be the type of my parser?? parser :: String -> ?? Any suggestion woud be very welcome indeed, titto

3 4

Re: [Haskell] reading from stdin
by Stefan O'Rear 05 Oct '07

05 Oct '07

On Thu, Oct 04, 2007 at 05:46:09PM +0100, Axel Simon wrote: > Hi, > > I'm trying to continuously output data to a file handle while reading > single characters from the user to adjust the speed at which things are > output. I'm interested to get this to work in Hugs on Windows. > I successfully used the following function ghci under Mac OS: > > {{{ > getUserInput :: IO (Maybe Char) > getUserInput = do > hasInput <- hReady stdin > if hasInput then liftM Just (hGetChar stdin) else return Nothing > }}} > > This function returns a character to me if there's one available. > If anybody could give me a hint how to get this working in Hugs under > Windows, please tell me. Something in the 'win32' package, or maybe the FFI. MSDN will be very handy. > P.S.: Sorry to post to haskell@..., but nothing else seemed to match. This is a thread for haskell-cafe@. Stefan

1 0

gtk2hs in Ubuntu Gutsy
by Chad Scherrer 05 Oct '07

05 Oct '07

I just installed the beta release for Ubuntu Gutsy, and I noticed that gtk2hs (provided by libghc6-gtk-dev) is still at version 0.9.10.5-1ubuntu1. Worse, it's apparently not installable; when I try I get this message: libghc6-gtk-dev: Depends: ghc6 (<6.6+) but 6.6.1-2ubuntu2 is to be installed Depends: libghc6-cairo-dev but it is not going to be installed Do any of you guys know why this wouldn't include a newer version? Probably just an oversight, I'm guessing. -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

2 1

GHC doesn't work
by Andrew Coppin 05 Oct '07

05 Oct '07

Greetings. I have a PC that had GHC 6.6 running on it. Worked fine. Then I uninstalled 6.6 and installed 6.6.1, and now it doesn't appear to work at all. Any attempt to run GHC results in a message that says The entry point OpenThread could not be found in KERNEL32.dll. or something very similar to that. Is this likely to be because GHC 6.6.1 doesn't support Windows NT, or because my PC is messed up?

2 2

Function composition
by Tiago Miguel Laureano Alves 05 Oct '07

05 Oct '07

Hi, I'm playing a little bit with pointfree and function composition and I would like to ask you if the following is theoretical correct and how can I express it in haskell. Imagine that I have the following functions f :: a -> b -> c -> d g :: d -> e I want to compose these two functions such that: (g . f) :: a -> b -> c -> e in which a, b and c are arguments of the composition. Is this theoretically correct? I tried this in haskell and ghc gives me an error saying that the function g should be of type b -> c -> d. With this I assume that when I specify f :: a -> b -> c -> d I'm really specifying f :: a -> (b -> c -> d) and such the composition doesn't work, but is it possible to overcome this? Kind regards, Tiago

5 5

bizarre memory usage with data.binary
by Anatoly Yakovenko 04 Oct '07

04 Oct '07

i am getting some weird memory usage out of this program: module Main where import Data.Binary import Data.List(foldl') main = do let sum' = foldl' (+) 0 let list::[Int] = decode $ encode $ ([1..] :: [Int]) print $ sum' list print "done" it goes up to 500M and down to 17M on windows. Its build with ghc 6.6.1 with the latest data.binary Any ideas what could be causing the memory usage to jump around so much? Thanks, Anatoly

10 17

Why not assign a type to unsafePerformIO?
by Justin Bailey 04 Oct '07

04 Oct '07

One of the "holes" in real-world Haskell is you never know if a library/function is calling unsafePerformIO and you have to trust the library author. I recognize the necessity of the function, but should it announce itself? unsafePerformIO has this type: unsafePerformIO :: IO a -> a Would there be any value to making it have a type that can be stripped off, like some other monads? For example, providing a "runUnsafe" or similar: data UnsafePerformIO a = Unsafe a runUnsafe :: UnsafePerformIO a -> a runUnsafe (Unsafe o) = o and changing unsafePerformIO to have the type: unsafePerformIO :: IO a -> UnsafePerformIO a It seems it would be valuable to have functions announce when they use unsafePerformIO, but additionally allow it to be stripped off. So the classic launchMissiles :: a -- Uses unsafePerfomIO! Would become launchMissiles :: UnsafePerformIO a Which could be stripped off it you wanted: evilDictatator :: a evilDictator = runUnsafe $ launchMissiles But doesn't have to be: incompetentDictator :: a incompetentDictator = launchMissiles -- Doesn't type check! I doubt this is original - does it buy anything? Justin

3 2

Re: [Haskell-cafe] Why not assign a type to unsafePerformIO?
by Justin Bailey 04 Oct '07

04 Oct '07

On 10/3/07, Victor Nazarov <asviraspossible(a)gmail.com> wrote: > > But how would you know that evil dictator uses unsafePerformIO??? You don't. unsafePerformIO can't be taken it away (there are legitimate reasons to strip IO), which is why I wonder if it's useful at all. p.s. CC'ed to haskell-cafe

2 1

Curry and uncurry
by PR Stanley 04 Oct '07

04 Oct '07

Hi The following is from the Hutton book: Without looking at the standard prelude, define the higher-order library function curry that converts a function on pairs into a curried function, and conversely, the function uncurry that converts a curried function with two arguments into a function on pairs. Hint: first write down the types of the two functions. I didn't even know about the curry and uncurry functions. I'm not looking for the answer but some guidance would be much appreciated. Thanks, Paul

4 3

PROPOSAL: New efficient Unicode string library.
by Johan Tibell 03 Oct '07

03 Oct '07

Dear haskell-cafe, I would like to propose a new, ByteString like, Unicode string library which can be used where both efficiency (currently offered by ByteString) and i18n support (currently offered by vanilla Strings) are needed. I wrote a skeleton draft today but I'm a bit tired so I didn't get all the details. Nevertheless I think it fleshed out enough for some initial feedback. If I can get the important parts nailed down before Hackathon I could hack on it there. Apologies for not getting everything we discussed on #haskell down in the first draft. It'll get in there eventually. Bring out your Unicode kung-fu! http://haskell.org/haskellwiki/UnicodeByteString Cheers, Johan Tibell

27 60

"with" and "preserving" for local state
by Jules Bean 03 Oct '07

03 Oct '07

Lots of external libraries contain state, but one that really contains a *lot* of state is the OpenGL libraries, since OpenGL is specified as a statemachine. This means that when you're writing structured code you quite often want to save and restore chunks of state 'automatically'. For the very most common case (coordinate transformations) Sven gives us 'preservingMatrix' which is extremely handy. Unless I've missed something there's no similar API for saving/restoring arbitrary state variables. It's not hard to write: > {-# OPTIONS -fglasgow-exts #-} > import Graphics.Rendering.OpenGL > import Graphics.UI.GLUT > > preserving :: (HasSetter g, HasGetter g) => g a -> IO t -> IO t > preserving var act = do old <- get var > ret <- act > var $= old > return ret This enables us to write preserving lighting $ do ..... Note that, since IORef is an instance of HasGetter and HasSetter, you can do 'preserving' on any old IORef, not just an openGL StateVar. Also note that the 'makeStateVar' interface that Graphics.Rendering.OpenGL.GL.StateVar exports allows you to make a statevar out of any appropriate action pair (not entirely unrelated to http://twan.home.fmf.nl/blog/haskell/overloading-functional-references.deta…) Sometimes you don't only want to preserve a value, but set a specific temporary value, so: > with :: (HasSetter g, HasGetter g) => g a -> a -> IO t -> IO t > with var val act = do old <- get var > var $= val > ret <- act > var $= old > return ret with lighting Enabled $ do .... (of course, with could be written as with var val act = preserving var $ var $= val >> act ) But this gets really clumsy if you have multiple variables to save/restore, which is really what lead me to write this message in the first place. A cute syntax for doing multiple save/restores at once is given by an existential: > data TemporaryValue = forall a g. > (HasGetter g,HasSetter g) => > g a := a > > with' :: [TemporaryValue] -> IO t -> IO t > with' tvs act = do olds <- mapM (\(a := b) -> do old <- get a > return (a := old)) > tvs > ret <- act > mapM_ (\(a := b) -> a $= b) tvs > return ret so we can then write: with' [lighting := Enabled, currentColor := Color4 1 0 1 0] $ do ... and have a type safe list of temporary assignments passed as an argument. And, amazingly, you get decent error messages too: *Main> :t with' [lighting := Enabled, currentColor := Color4 1 0 1 0] with' [lighting := Enabled, currentColor := Color4 1 0 1 0] :: IO t -> IO t *Main> :t with' [lighting := Enabled, currentColor := "Foo"] <interactive>:1:44: Couldn't match expected type `Color4 GLfloat' against inferred type `[Char]' In the second argument of `(:=)', namely `"Foo"' In the expression: currentColor := "Foo" In the first argument of `with'', namely `[lighting := Enabled, currentColor := "Foo"]' Hope someone else finds that useful, Jules

1 0

Parsing R5RS Scheme with Parsec
by Pasqualino 'Titto' Assini 03 Oct '07

03 Oct '07

Hi Alex, I hope not to spoil your fun but have you had a look at this: Write Yourself a Scheme in 48 Hours http://halogen.note.amherst.edu/~jdtang/scheme_in_48/tutorial/overview.html Regards, titto

2 1

Re: [Haskell-cafe] Assignment, Substitution or what?
by PR Stanley 03 Oct '07

03 Oct '07

> > > f x = x + x > > > Is the "x" use to create a pattern in the definition and when f is > > > called it's replaced by a value? > > > >Those equation-like definitions are syntactic sugar for lambda > >abstractions. f could as well be defined as f = \x -> x + x. > >Please elaborate > > >First, the > >f x = > >part says that f is a function which takes a single parameter, >called x. The other side of the = sign gives the function body: in >this case, x + x. This is exactly the same thing that is expressed >by the lambda expression > >\x -> x + x > >This expression defines a function that takes a single parameter >called x, and returns the value of x + x. The only difference is >that with the lambda expression, this function is not given a >name. But you can easily give the function a name (just as you can >give any Haskell expression a name) by writing > >f = \x -> x + x > >In general, writing > >g x y z = blah blah > >is just a shorthand for > >g = \x -> \y -> \z -> blah blah. > >That is, it simultaneously creates a function expression, and >assigns it a name. > >Does that help? Yes and thanks for the reply. When a function is declared in C the argument variable has an address somewhere in the memory: int f ( int x ) { return x * x; } any value passed to f() is assigned to x. x is the identifier for a real slot in the memory (the stack most likely) made available for f(). Is this also what happens in Haskell? Thanks, Paul

4 3

build problems with hscurses
by brad clawsie 03 Oct '07

03 Oct '07

hoping someone here can help me with a build problem when going through the hackage "build" stage, i get numerous errors like: HSCurses/Curses.hs:XXXX:0: invalid preprocessing directive #def where XXXX ranges in lines from 1597 to 1621. is there a special directive i need for runhaskell? any info appreciated. (on freebsd6.2, ghc6.6.1, ncurses-5.6_1)

1 1

Installation of GLFW package
by Immanuel Normann 03 Oct '07

03 Oct '07

Hello, I have just read the thread about "installation of GLUT package" started at 9/3/2007 by Ronald Guida. Installation of the GLFW package is very much related to that. However, I haven't found the solution for installing the GLFW successsfully. I have downloaded http://www.cs.yale.edu/homes/hl293/download/GLFW-20070804.zip and followed the compile and installation instructions from the README.txt file. Actually I haven't noticed any error messages. Then I tried SimpleGraphics from SOE (downloaded from http://www.cs.yale.edu/homes/hl293/download/SOE-20070830.zip) with ghci-6.6. Again loading the file did not raise any error. But when I tried to start main = runGraphics ( do w <- openWindow "My First Graphics Program" (300,300) drawInWindow w (text (100,200) "Hello Graphics World") k <- getKey w closeWindow w ) I got this error message: "During interactive linking, GHCi couldn't find the following symbol: GLFWzm0zi1_GraphicsziUIziGLFW_initializze_closure This may be due to you not asking GHCi to load extra object files, archives or DLLs needed by your current session. Restart GHCi, specifying the missing library using the -L/path/to/object/dir and -lmissinglibname flags, or simply by naming the relevant files on the GHCi command line. Alternatively, this link failure might indicate a bug in GHCi." Here I am lost. What is the missing library? Regards, Immanuel

3 3

Parsing R5RS Scheme with Parsec
by Alex Queiroz 03 Oct '07

03 Oct '07

Hallo, For fun and learning I'm trying to parse R5RS Scheme with Parsec. The code to parse lists follows: -- -- Lists -- parseLeftList :: Parser [SchDatum] parseLeftList = do char '(' many parseDatum >>= return . filter (/= SchAtmosphere) parseDottedList :: [SchDatum] -> Parser SchDatum parseDottedList ls = do char '.' many1 parseAtmosphere d <- parseDatum many parseAtmosphere char ')' return $ SchDottedList ls d parseProperList :: [SchDatum] -> Parser SchDatum parseProperList ls = do char ')' return $ SchList ls parseList :: Parser SchDatum parseList = do ls <- parseLeftList (parseDottedList ls) <|> (parseProperList ls) I've factored out the common left sub-expression in parseLeftList. The problem is that "..." is a valid identifier so when inside the left of the list the parser sees a single dot, it tries to match it with "...", which fails. Can anybody give advice on how to rewrite these list parsing functions? Cheers, -- -alex http://www.ventonegro.org/

4 6

Using C-c C-l to load .hsc file into ghci in Emacs
by Johan Tibell 03 Oct '07

03 Oct '07

How can I get C-c C-l to first run cpp on a .hsc file and then load the .hs file? I checked out the network package from darcs and then did: Start ghci, C-c C-z, then: Prelude> :set -cpp And then pressed load, C-c C-l: Prelude> :load "/Users/tibell/src/haskell/network-bytestring/Network/Socket.hsc" <command line>: Could not find module `/Users/tibell/src/haskell/network-bytestring/Network/Socket.hsc': Use -v to see a list of the files searched for. Failed, modules loaded: none. Prelude> :load "/Users/tibell/src/haskell/network-bytestring/Network/Socket.hsc" <command line>: Could not find module `/Users/tibell/src/haskell/network-bytestring/Network/Socket.hsc': Use -v to see a list of the files searched for. Failed, modules loaded: none.

1 0

Unfriendly hs-plugins error
by Björn Buckwalter 02 Oct '07

02 Oct '07

Dear all, I'm getting a rather unfriendly error when trying to load a plugin with hs-plugins: my_program: Ix{Int}.index: Index (65536) out of range ((0,7)) The exact numbers in the message vary depending on what I'm trying to do. I'm using GHC-6.6.1 on MacOS X. Here are three files that exhibit the behaviour for me: API.lhs ======= > module API where > data Config = Config { param :: String } Main.lhs ======== > module Main where > import System (getArgs) > import System.Plugins > import API > getConfig :: [String] -> IO Config > getConfig [file] = do > status <- make file [] > obj <- case status of > MakeSuccess _ o -> return o > MakeFailure es -> mapM_ putStrLn es >> error "make failed" > putStrLn $ "### loading " ++ file > m_v <- load_ obj ["."] "config" > putStrLn $ "### checking " ++ file > val <- case m_v of > LoadSuccess _ v -> return v > LoadFailure es -> mapM_ putStrLn es >> error "load failed" > return val > main = getArgs >>= getConfig >>= putStrLn . param CustomConfig.hs =============== >module CustomConfig where > import API > config = Config { param = "Doomed to fail!" } I compile the above with "ghc --make -o my_program PluginTest.lhs" and execute with "./my_program CustomConfig.lhs". Any hints welcome. Thanks, Bjorn Buckwalter

3 4

Assignment, Substitution or what?
by PR Stanley 02 Oct '07

02 Oct '07

Hi f x = x + x Is the "x" use to create a pattern in the definition and when f is called it's replaced by a value? What's actually happening here? Thanks, Paul

5 5

Compose
by PR Stanley 01 Oct '07

01 Oct '07

Hi sumSquareEven = (sum.map (^2)).filter even I wrote this thinking i was being very clever. The question is asking to spot the error in f = compose [sum, map (^2), filter even] I've only seen [] used in list comprehension and initialisation. I conducted a mini search on compose earlier but to be honest it just made matters even less clear. So the question is, does compose as a function or keyword exist in Haskell and if so how can the above code frag be corrected? O and, is compose in any way related to curry and uncurry? Thanks v mucho, Paul

3 2

The kind of (->)
by jeeva suresh 01 Oct '07

01 Oct '07

Hi Guys! According ghci the kind of (->) is "?? -> ? -> *" What do the '??' mean? What is the difference between the '?' and the '*' Cheers -- -Jeeva

2 1

Yampa question
by Ryan Ingram 01 Oct '07

01 Oct '07

I'm deriving an FRP implementation based on the ideas presented in the Yampa Arcade paper (http://www.haskell.org/yale/papers/haskell-workshop03/) to improve my understanding of arrows, but I have a couple of questions. I'm using the following declaration for SF: > type DTime = Double > newtype SF a b = SF { runSF :: DTime -> a -> (b, SF a b) } which I make an arrow in the obvious way: > instance Arrow SF where > arr f = SF sf where > sf dt b = (f b, SF sf) > bc >>> cd = SF sf where > sf dt b = (d, bc' >>> cd') where > (c, bc') = runSF bc dt b > (d, cd') = runSF cd dt c > first bc = SF sf where > sf dt ~(b,d) = ((c,d), sfFirst bc') where > (c, bc') = runSF bc dt b One question I had was about the implementation of "first". Is it important that the pair match be lazy? Or is it safe to make it strict? What are the advantages and disadvantages of each choice? My other question had to do with ArrowChoice. > instance ArrowChoice SF where > left bc = SF sf where > sf dt (Right d) = (Right d, left bc) > sf dt (Left b) = (Left c, left bc') where > (c, bc') = runSF bc dt b What happens to the dt in the "Right d" case? It seems to be invisible to the inner signal function. Is this the right thing to do? I have an alternate implementation which does the following: > sf dt (Right d) = (Right d, left $ addtime dt bc) > addtime :: DTime -> SF a b -> SF a b > addtime add sf = SF sf' where > sf' dt a = runSF sf (dt + add) a but there's a pretty clear space leak here with repeated "Right" calls, and I'm not sure if the inner signal should see the lost time or not. Perhaps signal functions shouldn't be an instance of ArrowChoice at all? Any insights would be appreciated. -- ryan

2 1

Re: [Haskell-cafe] Rewriting filter with foldr
by PR Stanley 01 Oct '07

01 Oct '07

>Well, note that foldr takes a function of x, which produces a >function of xs. This function of xs either conses x onto it, or >leaves it unchanged. We can write this down explicitly by removing >the xs parameter and just writing what function should be produced: > >filter f = foldr (\x -> if (f x) then (x:) else id) [] That's one neat solution but it also raises a few questions for me: foldr :: (a -> b -> b) -> b -> [a] -> b yet you've managed to squeeze in a function that takes only one argument. How is this possible without GHCI blowing its top? 2. Could you please explain the role of the identity function (id) in your code? Where's its argument, or is it sort of implicitly noted? For example, is it the case that the second argument is held in reserve and passed to the first function which would take it, hence (x:) and id? Many thanks, Paul

3 2

Re: [Haskell-cafe] Rewriting filter with foldr
by PR Stanley 30 Sep '07

30 Sep '07

The question is asking for a new definition of filter using foldr. Sorry, I should have mentioned that before. Cheers, Paul At 14:26 30/09/2007, you wrote: >Perhaps a list comprehension better shows the intention of the >filter function: > >filter p xs = [x | x <- xs, p x] > >You can literally read that as "take all x from xs that satisfy p".

1 0

Rewriting filter with foldr
by PR Stanley 30 Sep '07

30 Sep '07

Hi filter :: (a -> Bool) -> [a] -> [a] filter f = foldr (\x -> \xs -> if (f x) then (x:xs) else xs) [] Somehow I feel this could be done more elegantly. What does the list think? Thanks, Paul

3 2

Re: [Haskell-cafe] Rewriting ord (revisited)
by PR Stanley 30 Sep '07

30 Sep '07

The second version looks very neat, certainly, though I am not entirely convinced that it's any more efficient. Still, I may be missing something. The compiler must be one hell of a machine. I wonder if the source code is available to the public. Cheers, Paul At 12:26 30/09/2007, you wrote: >-----BEGIN PGP SIGNED MESSAGE----- >Hash: RIPEMD160 > >I would think that the compiler is smart enough to fuse the two loops. >That doesn't explain the performance difference though. > >Adrian > > >PR Stanley schrieb: > > Hi > > This was my original version plus some modifications as advised by the > > list: > > f c = sum [1 | x <- ['\0'..], x < c] > > > > The following version was sent by a list member: > > f c = length $ takeWhile (<c) ['\0'..] > > > > Now, the sender asserted that the first version was much too slow. I'm > > wondering how the second version is any more efficient than the first. > > Looking at them through my C programmers' eye, as it were, both would > > require at least two loops before returning the ANSI value. > > Any ideas? > > Thanks, Paul > > > > _______________________________________________ > > Haskell-Cafe mailing list > > Haskell-Cafe(a)haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-cafe > >-----BEGIN PGP SIGNATURE----- >Version: GnuPG v1.4.7 (MingW32) >Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org > >iD8DBQFG/4f+11V8mqIQMRsRAxegAJ4t5grdRDrWVWby6tjDZDdxgJ72FQCfcD7W >Mntl7FV2GpCGtpY2yP61kbk= >=l+3X >-----END PGP SIGNATURE-----

2 1

Rewriting ord (revisited)
by PR Stanley 30 Sep '07

30 Sep '07

Hi This was my original version plus some modifications as advised by the list: f c = sum [1 | x <- ['\0'..], x < c] The following version was sent by a list member: f c = length $ takeWhile (<c) ['\0'..] Now, the sender asserted that the first version was much too slow. I'm wondering how the second version is any more efficient than the first. Looking at them through my C programmers' eye, as it were, both would require at least two loops before returning the ANSI value. Any ideas? Thanks, Paul

2 1

Compiling Simple Regex Program
by Andrew Trusty 30 Sep '07

30 Sep '07

Hello, I'm using GHC 6.6.1 under Windows XP and I can't get the following simple program to compile. import Text.Regex main = putStrLn (subRegex (mkRegex "c") "abc" "a") It runs in GHCi just fine but GHC gives the following output when trying to compile: project1.o(.text+0x169):fake: undefined reference to `regexzmcompatzm0zi71_Textz iRegex_mkRegex_closure' project1.o(.text+0x1f7):fake: undefined reference to `regexzmcompatzm0zi71_Textz iRegex_subRegex_closure' project1.o(.rodata+0x4):fake: undefined reference to `regexzmcompatzm0zi71_Textz iRegex_mkRegex_closure' project1.o(.rodata+0x8):fake: undefined reference to `regexzmcompatzm0zi71_Textz iRegex_subRegex_closure' collect2: ld returned 1 exit status

2 1

build problem (X11 under cabal)
by Jens Blanck 30 Sep '07

30 Sep '07

Not being very savvy in building things I got stuck when trying to build xmonad. It needs X11 1.2.2, so I tried to build that. Configuration step went fine (I believe), but buiding failed: > runhaskell Setup.hs build Preprocessing library X11-1.2.2... /usr/lib/gcc/i586-suse-linux/4.1.0/../../../../i586-suse-linux/bin/ld: cannot find -lX11 collect2: ld returned 1 exit status linking Graphics/X11/Types_hsc_make.o failed command was: /usr/bin/ghc-6.6 -lX11 Graphics/X11/Types_hsc_make.o -o Graphics/X11/Types_hsc_make Setup.hs: got error code while preprocessing: Graphics.X11.Types I have tried the ghc command seperately with the flag -L/usr/X11R6/lib which makes it compile. But I cannot figure out how to proceed from here. Jens

2 1

Re: [Haskell] Seemingly impossible Haskell programs
by Roberto Zunino 30 Sep '07

30 Sep '07

Graham Hutton wrote: > Readers of this list may enjoy the following note by > Martin Escardo, which shows how to write a number of > "seemingly impossible Haskell programs" that perform > exhaustive searches over spaces of infinite size, by > exploiting some ideas from topology: > > http://math.andrej.com/2007/09/28/seemingly-impossible-functional-programs/… Very nice! The note shows that you can actually compute (forall p) where p is a *total* predicate over streams of Bool (a.k.a. infinite lazy lists). Indeed, (writing [] for streams) forall :: ([Bool] -> Bool) -> Bool seems impossible to compute. Here's what I understood: (which might be wrong, of course!) This apparent magic relies on the fact that any total predicate over (total) bool streams, i.e. p :: [Bool] -> Bool can only inspect a _finite_ prefix of the input list. More importantly, the length of the inspected prefix has an upper bound which depends _only_ on p and not on the actual input of p. In rough formulas forall p, exists n:nat, forall l:[Bool], forall l':[Bool], p l == p (take n l ++ l') So, with some nice laziness tricks, you can actually check p over "all" the infinite [Bool] space, using only finite time. Zun.

2 1

Order of Declaration
by PR Stanley 30 Sep '07

30 Sep '07

Hi in C type languages a function must be declared before its application. Would I be right in thinking that this isn't the case in Functional languages? For example: transmit :: String -> String transmit = decode . channel . encode channel :: [[Int]] -> [[Int]] channel = id Cheers, Paul

3 2

Text.Html
by Bob 30 Sep '07

30 Sep '07

Hi everybody! Where can I find a documentation or a tutorial for html combinator library Text.Html?

2 1

Rewriting char
by PR Stanley 30 Sep '07

30 Sep '07

Hi Any advice on writing intToChar? I'm not looking for the code; only sound advice on writing the function in good FP style. Thanks, Paul

2 1

Rewriting Char.ord
by PR Stanley 29 Sep '07

29 Sep '07

Hi ord :: Char -> Int ord c = sum [1 | x <- ['\0'..'\255'], x < c] Any comments? Any alternatives? Cheers, Paul

4 4

agda v. haskell
by brad clawsie 29 Sep '07

29 Sep '07

dons has been posting some links regarding agda on reddit. fairly interesting, a quick glance and you think you are reading haskell code. does anyone have any insights on the major differences in these languages?

4 3

some simple proof exercises
by Tim Newsham 29 Sep '07

29 Sep '07

Here are two small problem sets of proofs of Haskell functions. They are aimed at people who do not have experience writing proofs and are not necessarily well versed in Haskell. Feedback is appreciated. http://www.thenewsh.com/%7Enewsham/formal/problems/set1.html http://www.thenewsh.com/%7Enewsham/formal/problems/set2.html Tim Newsham http://www.thenewsh.com/~newsham/

2 1

Newb: List of nodes in a graph - is there a prettier way?
by Torsten Otto 29 Sep '07

29 Sep '07

Howdy, I'm working towards Dijkstra's algorithm here and I have a feeling that I could do without the helper function nodesInternal in the following code, if I only could figure out how. Any hints would be appreciated. nodes::Graph->[Id] should (and actually does) return a list of all nodes in the graph. Thanks a bunch in advance. Regards, Torsten Otto >module Route where Datatypes for the representation of the graph: >type Id = Int >type Weight = Int >type Edge = (Id,Id) >type Graph = [ (Edge, Weight) ] >graph::Graph >graph = [ ((0,1),1), > ((0,2),3), > ((0,4),6), > ((1,2),1), > ((1,3),3), > ((2,0),1), > ((2,1),2), > ((2,3),1), > ((3,0),3), > ((3,4),2), > ((4,3),1), > ((5,2),9)] >data Cost = Finite Weight | Infinity > deriving (Eq, Ord, Show) >type PathCost = (Cost, Id) Return the number of edges in the graph: >edges :: Graph -> Int >edges graph = length graph Calculate the sum of all weights: >weightTotal::Graph -> Weight >weightTotal ((edge, weight):xs)| xs == [] = weight > | otherwise = weight + (weightTotal xs) List all the nodes in the graph: >nodes::Graph -> [Id] >nodes graph = nodesInternal [] graph >nodesInternal::[Id]->Graph->[Id] >nodesInternal list (((id1,id2),weight):xs) > | (elem id1 list) && (elem id2 list) = nodesInternal list xs > | (elem id1 list) && (not (elem id2 list)) = nodesInternal (id2:list) xs > | (not (elem id1 list)) && (elem id2 list) = nodesInternal (id1:list) xs > | (not (elem id1 list)) && (not (elem id2 list)) = nodesInternal (id1:id2:list) xs >nodesInternal list [] = list Function for adding costs so that we can make use of Infinity for impossible routes: >addCosts::Cost -> Cost -> Cost >addCosts Infinity Infinity = Infinity >addCosts Infinity (Finite x) = Infinity >addCosts (Finite x) Infinity = Infinity >addCosts (Finite x) (Finite y) = Finite (x + y) Return the cost of a given edge: >lookUp::Edge -> Graph -> Cost >lookUp (id1,id2) (((id1x,id2x),weightx):xs) > | (id1==id1x && id2==id2x) = Finite weightx > | xs==[] = Infinity > | otherwise = lookUp (id1,id2) xs

3 3

Dynamic choice of "reverse" implementation
by Krzysztof Kościuszkiewicz 29 Sep '07

29 Sep '07

Fellow Haskellers, I wanted to experiment a bit with lists and sequences (as in Data.List and Data.Sequence), and I got stuck. I wanted to dynamically select processing function depending on cmdline argument: > main = do > args <- getArgs > let reversor = case args of > ["sequence"] -> reverseList > ["list"] -> reverseSeq > _ -> error "bad args" > input <- getContents > let output = reversor $ lines $ input > mapM_ putStrLn output In my oppinion reversor would have type > reversor :: (Foldable f) => [a] -> f b but I couldn't get this to work. I've tried typeclass approach: > class (Foldable f) => Reversor f where > reverse' :: [a] -> f a > > instance Reversor ([]) where > reverse' = Data.List.reverse > > instance Reversor ViewR where > reverse' = viewr . foldr (<|) empty > > reverseList = reverse' :: (???) > reverseSeq = reverse' :: (???) but now in order to differentiate between "reverse'" functions I'd have to provide different type annotations, and then "reversor" won't typecheck... Similar problem surfaced with this try: > data Proc = SP | LP > reverseList = reverse' LP > reverseSeq = reverse' SP > > reverse' :: (Foldable f) => Proc -> [a] -> f a > reverse' LP = Data.List.reverse > reverse' SP = viewr . foldr (<|) empty So now I'm looking for some suggestions how should I approach the problem... Regards, -- Krzysztof Kościuszkiewicz Skype: dr.vee, Gadu: 111851, Jabber: kokr(a)jabberpl.org Mobile IRL: +353851383329, Mobile PL: +48783303040 "Simplicity is the ultimate sophistication" -- Leonardo da Vinci

6 8

Opengl and Haskell GLdouble/GLfloat vs. Double/Float
by bbrown 29 Sep '07

29 Sep '07

I am going to be doing a lot of opengl stuff in haskell and so far one thing has irked me. Why does haskell keep the GLFloat and GL types and not just the Haskell types. -- Berlin Brown [berlin dot brown at gmail dot com] http://botspiritcompany.com/botlist/?

3 2

Newb question about map and a list of lists
by Chuk Goodin 29 Sep '07

29 Sep '07

I have a list of lists of pairs of numeric Strings (like this: [["2","3"],["1","2"],["13","14"]] etc.) I'd like to change it into a list of a list of numbers, but I'm not sure how to go about it. If it was just one list, I could use map, but map.map doesn't seem to work. Any suggestions, or pointers to a reference online? thanks in advance, -- chuk

5 4

Packages and "how to load them"
by bbrown 29 Sep '07

29 Sep '07

If I have a set of haskell code and I create a directory with the source that has the following imports. (some_dir/MyLib.hs) module MyLib where And then I want to use that set of code at the top level directory, eg: MyTest.hs import MyLib How would I compile with ghc such that it loads the code from "some_dir" without it having to have the module as "module some_dir.MyLib". I think this is a basic packaging question but couldnt figure it out. -- Berlin Brown [berlin dot brown at gmail dot com] http://botspiritcompany.com/botlist/?

3 2

int to bin, bin to int
by PR Stanley 28 Sep '07

28 Sep '07

Hi intToBin :: Int -> [Int] intToBin 1 = [1] intToBin n = (intToBin (n`div`2)) ++ [n `mod` 2] binToInt :: [Integer] -> Integer binToInt [] = 0 binToInt (x:xs) = (x*2^(length xs)) + (binToInt xs) Any comments and/or criticisms on the above definitions would be appreciated. Thanks , Paul

6 5

signals lib
by brad clawsie 28 Sep '07

28 Sep '07

does System.POSIX.Signals bind to OS specific real-time POSIX signal apis? (i.e., kqueue on freebsd).

2 1

Postdoctoral Fellowship in Functional Programming
by Graham Hutton 28 Sep '07

28 Sep '07

+--------------------------------------------------------------------+ POSTDOCTORAL RESEARCH FELLOW IN FUNCTIONAL PROGRAMMING School of Computer Science University of Nottingham, UK Applications are invited for a 3-year postdoctoral research fellowship in functional programming, to work with Dr Graham Hutton on the EPSRC-funded project "Reasoning About Exceptions and Interrupts". Most modern programming languages provide special features for detecting and managing unexpected events, in the form of exception and interrupt handling primitives. Despite their importance, the issue of provable correctness for programs involving these features has received little attention, but is particularly crucial given the difficulty of writing correct programs in this setting. The aim of this project is to address this problem within the context of modern functional programming languages such as Haskell and Epigram. Applicants for this position will require a PhD in Computer Science, and research experience in functional programming. Additional desirable attributes include experience in formal semantics, program verification, concurrency theory, or theorem provers. The successful applicant will work in collaboration with Dr Graham Hutton in the Foundations of Programming group in Nottingham, a leading centre for research on formal approaches to software construction and verification. The group currently comprises 7 academic staff, 5 research staff, and 13 PhD students. Salary will be within the range 25,134 - 32,796 pounds per year, depending on qualifications and experience. The post is available immediately, and will be offered on a fixed-term contract for 3 years. Further details regarding the position and how to apply are available from Dr Graham Hutton, http://www.cs.nott.ac.uk/~gmh. Closing date for applications: 12th October 2007. +--------------------------------------------------------------------+ | Dr Graham Hutton Email : gmh(a)cs.nott.ac.uk | | School of Computer Science | | University of Nottingham Web : www.cs.nott.ac.uk/~gmh | | Jubilee Campus, Wollaton Road | | Nottingham NG8 1BB, UK Phone : +44 (0)115 951 4220 | +--------------------------------------------------------------------+ This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

4 3

Praise for xmonad :-)
by Magnus Therning 28 Sep '07

28 Sep '07

Seems xmonad is feeling the love. The attached mail turned up on the debian-user mailing list. It's high time xmonad gets packaged for Debian! /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus＠therning．org Jabber: magnus．therning＠gmail．com http://therning.org/magnus

3 3

getting more out of ghci [longish]
by Claus Reinke 28 Sep '07

28 Sep '07

== intro no, i'm not talking about using a nice frontend to ghci, with added functionality, although the haskell modes for emacs and vim, and other such gui/ide/editor efforts, are well worth looking into!-) also, i'm not going to talk about the eagerly anticipated ghci debugger. what i am going to talk about are some of the little things one can do to improve the ghci user experience, including features asked for in ghc's ticket tracker, features known and cherished from hugs, and features that are not even available in hugs. the keys to adding such useful features are :def, which allows us to define new ghci commands, and :redir, which allows us to capture the output of ghci commands for further processing. and to save you the search: :def has been with us for a while (it is in ghci 6.6.1), and :redir is not among the pre-defined ghci commands, not even in ghc head. the reason i started looking into adding commands to ghci were (a) the added functionality in ghci 6.7, which will (b) soon require me to be able to capture ghci command output, for proper interfacing with my haskell mode plugins for vim. originally, i thought that output capture would need to be hacked into the ghci sources (i even drafted a patch:-). it then became clear that we can implement :redir on top of the existing commands, even in ghci 6.6.1! all the commands we're going to introduce are defined in the file dot-squashed.ghci, which can be found here: http://www.cs.kent.ac.uk/~cr3/toolbox/haskell/dot-squashed.ghci (there is a patch pending for ghc head that will let us spread definitions in ghci over multiple lines, but for now, we have to squash them into single lines..; i will take the liberty to violate this restriction in the explanations below), and work with ghci 6.6.1, although there are more commands and information to play with in ghc 6.7 or later. == command overview so what kind of commands are we going to define? here's an overview: Prelude> :def s readFile Prelude> :s dot-squashed.ghci Prelude> :defs list :. <file> -- source commands from <file> :pwd -- print working directory :ls [<path>] -- list directory ("." by default) :redir <var> <cmd> -- execute <cmd>, redirecting stdout to <var> :redirErr <var> <cmd> -- execute <cmd>, redirecting stderr to <var> :grep <pat> <cmd> -- filter lines matching <pat> from the output of <cmd> :find <id> -- call editor (:set editor) on definition of <id> :b [<mod>] -- :browse <mod> (default: first loaded module) :le [<mod>] -- try to :load <mod> (default to :reload); edit first error, if any :defs {list,undef} -- list or undefine user-defined commands == let's go - simple things first :def is commonly used to abbreviate frequently entered commands: Prelude> :grep :def :? :def <cmd> <expr> define a command :<cmd> where the <expr> is of type 'String -> IO String', so it takes a command parameter (actually, the rest of the command line after :<cmd>), does some IO, and returns a String, which is going to be interpreted as ghci input. that's why our ':def s readFile' defined a :s command to source ghci input from a file, which we then used to source our new command definitions (alternatively, we could have put those into our .ghci file). ghci 6.7 and later also have a :cmd command, which takes an expression of type 'IO String' - that expression is immediately executed, and its result String is interpreted as ghci input. we'll define our own version for ghci 6.6.1: -- 6.6.1 doesn't have this, omit this def for later ghci's :def cmd \l->return $ unlines [":def cmdTmp \\_->"++l,":cmdTmp",":undef cmdTmp"] we simply use the expression parameter to define a temporary command, which we execute immediately and undefine afterwards. == being helpful and self-documenting ghci only keeps an internal record of commands added with :def, so we can neither get a list of them, nor will they appear in :? output. we can be more helpful by wrapping each command with a line of help: -- make commands helpful let { cmdHelp cmd msg "--help" = return $ "putStrLn "++show msg ; cmdHelp cmd msg other = cmd other } then we can define a few standard utilities, with help texts: :def . cmdHelp readFile ":. <file>\t\t-- source commands from <file>" let pwd _ = return "System.Directory.getCurrentDirectory >>= putStrLn" :def pwd cmdHelp pwd ":pwd\t\t\t-- print working directory" let ls p = return $ "mapM_ putStrLn =<< System.Directory.getDirectoryContents "++show path where {path = if (null p) then "." else p} :def ls cmdHelp ls ":ls [<path>]\t\t-- list directory (\".\" by default)" sourcing commands saves key-strokes on a frequently used operation, while :pwd and :ls save me from having to recall whether i'm using ghci in windows or unix, by using haskell functions;-) we'll see later how we register our commands with :defs, but each of these commands responds to calls for --help: Prelude> :. --help :. <file> -- source commands from <file> so, once registered, we can let :defs give us --help for all of them: Prelude> :grep :\.|:pwd|:ls :defs list :. <file> -- source commands from <file> :pwd -- print working directory :ls [<path>] -- list directory ("." by default) == a hammer for many nails: capturing ghci command output now for the big tool: :def is fine, and there are several ghci commands that give useful information to the user, such as :?, :show modules, :browse, etc. if we could only get hold of that information, we could define much more interesting new ghci commands. the plan is to redirect stdout to a temporary file, execute one of those helpful ghci commands, restore stdout to the terminal, and read the contents of the temporary file into a variable (then clean away the temporary file). unfortunately, there's no portable redirection functionality in the standard libs, but in ghci, we're ghc-dependent anyway, and ghc provides us with GHC.Handle. now, take a deep breath, 'cause here we go: let redir varcmd = case break Data.Char.isSpace varcmd of { (var,_:cmd) -> return $ unlines [":set -fno-print-bind-result" ,"tmp <- System.Directory.getTemporaryDirectory" ,"(f,h) <- System.IO.openTempFile tmp \"ghci\"" ,"sto <- GHC.Handle.hDuplicate System.IO.stdout" ,"GHC.Handle.hDuplicateTo h System.IO.stdout" ,"System.IO.hClose h" ,cmd ,"GHC.Handle.hDuplicateTo sto System.IO.stdout" ,"let readFileNow f = readFile f >>= \\t->length t `seq` return t" ,var++" <- readFileNow f" ,"System.Directory.removeFile f"] ; _ -> return "putStrLn \"usage: :redir <var> <cmd>\"" } :def redir cmdHelp redir ":redir <var> <cmd>\t-- execute <cmd>, redirecting stdout to <var>" okay, that was a handful, and it doesn't look easier on a single line. our :redir command takes two parameters: the name of a variable to bind the output to, and the name of a command to capture the output of. so we split the command line into var and cmd, and we complain with usage info if that fails (unchecked failure in ghci command definitions is generally a bad idea). the rest is fairly straightforward, actually, but for the tedious inconvenience of keeping the different levels of interpretation and scopes in mind: we're using the current scope to construct strings that represent commands which will be executed in the scope in which :redir will be called. also, we need to fully qualify our variables, to be sure we can get the right ones, no matter what module is loaded when the command is executed (strictly speaking, we should qualify the remaining functions as well, to avoid pathological cases like "import Prelude()" -- please keep that in mind if you do redefine or hide any of those standard functions). we don't want output from our auxiliary variable bindings, so we :set -fno-print-bind-result; then we get a temporary file f, with handle h, make a copy of stdout, then redirect stdout to h; we insert the cmd we want to run (note the lack of quotes); afterwards, we restore stdout, read the temporary file and bind its contents to var (note again the quoting), before we clear away the temporary file. and what do we get for all that trouble? Prelude> :redir --help :redir <var> <cmd> -- execute <cmd>, redirecting stdout to <var> Prelude> :redir x :type id Prelude> x "id :: a -> a\n" Prelude> putStrLn x id :: a -> a not much, yet, but that is a very useful hammer!-) and if :redir is our hammer, the question becomes: what are our nails? == filtering command output we've already seen several uses of :grep, so let's deal with that next: let { merge [] = [] ; merge (l:c:ls) | i c > i l = merge ((l++c):ls) where {i l = length (takeWhile Data.Char.isSpace l)} ; merge (l:ls) = l:merge ls ; grep patcmd = case break Data.Char.isSpace patcmd of { (pat,_:cmd) -> return $ unlines [":redir out "++cmd ,"let ls = "++if ":browse" `Data.List.isPrefixOf` cmd then "merge (lines out)" else "lines out" ,"let match pat = Data.Maybe.isJust . Text.Regex.matchRegex (Text.Regex.mkRegex pat)" ,"putStrLn $ unlines $ (\"\":) $ filter (match "++show pat++") $ ls"] ; _ -> return "putStrLn \"usage: :grep <pat> <cmd>\"" } } :def grep cmdHelp grep ":grep <pat> <cmd>\t-- filter lines matching <pat> from the output of <cmd>" -- (also merges pretty-printed lines if <cmd> is :browse) another handful, but not all that much if we focus on the grep function: again, we split the commandline into pat and cmd (note that this simple-minded approach doesn't permit spaces in pat); we then run the cmd, capturing its output in the variable out, and apply a simple filter to the lines in out, based on matching the regular expression pattern pat; that's it (oh, and if cmd happens to be :browse, we undo the pretty-printer's attempt to spread information over multiple lines, which would interfere with our line-based filtering). now, this is more obviously useful, isn't it?-) we can :grep for module-related commands in :?: Prelude> :grep mod :? :add <filename> ... add module(s) to the current target set :browse [*]<module> display the names defined by <module> :edit edit last module :load <filename> ... load module(s) and their dependents :module [+/-] [*]<mod> ... set the context for expression evaluation :reload reload the current module set :show modules show the currently loaded modules or find out what folds there are in the Prelude (this is similar to hugs' :names command, btw): Prelude> :grep fold :browse Prelude foldr :: (a -> b -> b) -> b -> [a] -> b foldl1 :: (a -> a -> a) -> [a] -> a foldr1 :: (a -> a -> a) -> [a] -> a foldl :: (a -> b -> a) -> a -> [b] -> a or what monadic commands in the Prelude operate on lists (this is no replacement for hoogle, but useful for finding simple matches): Prelude> :grep Monad.*\[.*\] :browse Prelude sequence_ :: (Monad m) => [m a] -> m () sequence :: (Monad m) => [m a] -> m [a] mapM_ :: (Monad m) => (a -> m b) -> [a] -> m () mapM :: (Monad m) => (a -> m b) -> [a] -> m [b] == for our next trick: more hugs commands for ghci === :find we've already included the :names functionality, but my favourite hugs command must be :find <name>, which edits the module containing the definition of <name>. this is even more useful as hugs comes with sources for Prelude and libs, so you can simply say ':find span' and see span's standard definition. but, let's at least define a ghci :find for modules for which we do have the sources! the plan is to capture the output of :info <name>, grep for those helpful comments "-- Defined at <file>:<line>:<col>:", which tell us where to look, then call :edit with that information. for that to work, we need an editor that can open a file at a specified line: -- if your editor doesn't understand :e +line file -- (jump to line in file), you'll need to change -- functions find and loadEditErr below :set editor gvim now, for the find functionality: let find id = return $ unlines [":redir out :info "++id ,"let ls = filter (Data.List.isInfixOf \"-- Defined\") $ lines out" ,"let match pat = Text.Regex.matchRegex (Text.Regex.mkRegex pat)" ,"let m = match \"-- Defined at ([^<:]*):([^:]*):\" $ head ls" ,":cmd return $ case (ls,m) of { (_:_,Just [mod,line]) -> (\":e +\"++line++\" \"++mod) ; _ -> \"\" }"] :def find cmdHelp find ":find <id>\t\t-- call editor (:set editor) on definition of <id>" that's fairly easy by now, isn't it?-) we capture the output of :info, grab the definition location, if any, and call :e. the latter is a bit tricky because we need to compose the :e command with the information we have obtained from :info. we achieve this by an extra level of interpretation, passing our constructed ':e +line file' command to :cmd. note again that :find will work only where we have the sources. for instance, we don't have the sources for Prelude.span, so :find span wouldn't work - :info span doesn't list a source file, only a module: Prelude> :info span span :: (a -> Bool) -> [a] -> ([a], [a]) -- Defined in GHC.List but load a module of your own, then try ':find main' or something!-) === #1468: :browse should browse currently loaded module another thing that hugs does is default to browsing the current module, if :browse is called with no explicit module parameter. this has been asked for in a ghci ticket. by now, you're probably ahead of me, looking for ghci commands to grab the current module from?-) you're looking for :show modules, and the implementation of :b is indeed straightforward: let { b browse "" = return $ unlines [":redir out :show modules" ,":cmd case lines out of { (l:_) -> return ("++show browse++"++head (words l)) ; _ -> return \"\" }"] ; b browse m = return (browse++m) } :def b cmdHelp (b ":browse ") ":b [<mod>]\t\t-- :browse <mod> (default: first loaded module)" i pass the browse command to use because my ghci has two versions (also in that patch pending for ghc head), and you might want to protect that call to head. but otherwise, no need to wait for someone to hack the ghci sources to fix that ticket!-) === #95: GHCi editor binding with ":e" the ghci ticket that asked for adding the hugs :edit command also asked for more of hugs :edit functionality: after failing to load a file, :e will edit the first error location. can we do that without fixing ghci? yes, we can, but there is a slight obstacle to overcome. we could make a variant of :redir that redirects stderr instead of stdout, but we want to apply it to commands like :load/:reload, to capture their error reports, if any. unfortunately, those commands clear the bindings in scope, which means that our cleanup operation would fail to restore stderr to the terminal, not to mention reading the tempfile contents into a variable. we need to be a bit more careful. fortunately, :l/:r do not clear the current commands, so if we manage to capture our handle and filename variables in a temporary command, we can execute that to finish processing after calling :l/:r. so, here we go: let redirErr varcmd = case break Data.Char.isSpace varcmd of { (var,_:cmd) -> return $ unlines [":set -fno-print-bind-result" ,"tmp <- System.Directory.getTemporaryDirectory" ,"(f,h) <- System.IO.openTempFile tmp \"ghci\"" ,"ste <- GHC.Handle.hDuplicate System.IO.stderr" ,"GHC.Handle.hDuplicateTo h System.IO.stderr" ,"System.IO.hClose h" ,"let readFileNow f = readFile f >>= \\t->length t `seq` return t" ,"let afterCmd _ = do { GHC.Handle.hDuplicateTo ste System.IO.stderr ; r <- readFileNow f ; System.Directory.removeFile f ; return $ \""++var++" <- return \"++show r }" ,":def afterCmd afterCmd" , cmd , ":afterCmd" , ":undef afterCmd" ] ; _ -> return "putStrLn \"usage: :redirErr <var> <cmd>\"" } :def redirErr cmdHelp redirErr ":redirErr <var> <cmd>\t-- execute <cmd>, redirecting stderr to <var>" if you compare redirErr with redir, you'll notice that we've only exchanged stderr for stdout, and moved the commands after cmd into a temporary :afterCmd, which slightly complicates the quoting. otherwise, the plan is unchanged. we're now in a position to handle error location editing: let loadEditErr m = return $ unlines [if null m then ":redirErr err :r" else ":redirErr err :l "++m ,"let match pat = Text.Regex.matchRegex (Text.Regex.mkRegex pat)" ,"let ms = Data.Maybe.catMaybes $ map (match \"^([^:]*):([^:]*):([^:]*):\") $ lines err" ,":cmd return $ case ms of { ([mod,line,col]:_) -> (\":e +\"++line++\" \"++mod) ; _ -> \"\" }"] :def le cmdHelp loadEditErr ":le [<mod>]\t\t-- try to :load <mod> (default to :reload); edit first error, if any" depending on whether we use :le with an explicit module to load or not, we use :load or :reload, capture the error output, filter it for error locations (<file>:<line>:<col>:), and call the editor with that information for the first error, if any. we could even make ghci wait for the editor to close, then loop until all errors have been handled. but that kind of edit/compile loop is better handled inside your editor (in vim, :help quickfix). == wrapping up, keeping a list finally, let's keep a record of the command we've added, so that we can find out what they are and what they do: let { cmds = [".","pwd","ls","redir","redirErr","grep","find","b","le","defs"] ; defs "list" = return $ unlines $ "putStrLn \"\"": [":"++cmd++" --help"| cmd <- cmds]++ ["putStrLn \"\""] ; defs "undef" = return $ unlines [":undef "++cmd| cmd <- cmds] ; defs _ = return "putStrLn \"usage: :defs {list,undef}\"" } :def defs cmdHelp defs ":defs {list,undef}\t-- list or undefine user-defined commands" we simply list the commands manually (we could make them self-registering by keeping an IORef somewhere, but let's keep things simple for now), and provide an administrative interface (:defs) to list (call --help for all) or undefine (useful if you edit your .ghci file and want to reload it) all our commands. that's how we were able to type ':defs list' at the beginning of this session to get our overview of available user-defined commands. i hope you enjoyed this little tour of ghci, and find the proposed commands and techniques useful. claus

8 10

Data types and field labels and "Show"
by bbrown 28 Sep '07

28 Sep '07

I am trying to print the data from a data type and also get the field values. How would I reference those values if I am declaring a Show function. I should probably use a class for this, but so far it is working. I have something along the lines of this. data SimplePlayer = SimplePlayer { shape :: MechShape, angle :: GLfloat, posX :: GLfloat, posY :: GLfloat } and then to use "Show", I was declaring this. instance Show SimplePlayer where show a = "<Simple> posX [" ++ show a{posX} ++ "]" Of course, this didn't compile. How should I change this code to get the field label values of the type. Tests/GLTests.hs:20:42: parse error on input `}' -- Berlin Brown [berlin dot brown at gmail dot com] http://botspiritcompany.com/botlist/?

3 3

Desugaring of infix operators is (always?) the wrong way round
by Brian Hulley 27 Sep '07

27 Sep '07

Hi, I'm in the process of designing a little language inspired by Haskell but imperative, and have hit an issue regarding infix syntax which may be of interest also to anyone thinking about future revisions of Haskell or the problem of consistent parameter order in libraries. I'm wondering if anyone can shed light on the reason why x # y gets desugared to (#) x y and not (#) y x since the first desugaring always seems to lead to (#) having to be defined in a way that is unnatural for functional programming. This is why a lot of functions in the standard libraries have their arguments the wrong way round. For example in Data.Bits we have: shiftL :: a -> Int -> a whereas the natural argument order for a functional language would be to make it so that in an application one has the verb first followed by the noun as in: shiftL' :: Int -> a -> a so we could write (shiftL' 3) to denote the operation of shifting something left by 3 eg: let shiftLeftByThree = shiftL' 3 in map shiftLeftByThree [10, 78, 99, 102] (This choice of argument order is explained at http://www.haskell.org/haskellwiki/Parameter_order ) Similarly, considering arithmetic, it would make a lot more sense to me to define: x - y === (-) y x since the "action" here is "take away y" and the noun is "x" so the natural functional reading of (-) a b is "subtract a from b". To be consistent this would also have to apply to the use of (->) in types to get: a -> b === (->) b a Can anyone think of an example where the current desugaring of infix arguments gives the correct order when the function is used in a postfix application? (apart from commutative functions of course!) Thanks, Brian

8 16

distghc possible?
by wp 27 Sep '07

27 Sep '07

hi, i am a newbie in haskell. i have read about the tool distcc, http://distcc.samba.org/. so i was wondering, does something like this already exist for haskell? would it be possible to implement a similar tool based on ghc for haskell or does this not make sense as a haskell program has to be compiled all in one go? how are haskell programs compiled? it would be great if someone would have some suggestions on this. walter

2 1

Re: [Haskell-cafe] Haskell Cheat Sheet?
by Jonathan Cast 27 Sep '07

27 Sep '07

On Wed, 2007-09-26 at 17:09 -0500, Derek Elkins wrote: > On Wed, 2007-09-26 at 14:12 -0700, Jonathan Cast wrote: > > On Wed, 2007-09-26 at 11:43 -0700, Dan Weston wrote: > > > It seems no one liked idea #2. I still think fix is the wrong name for > > > this, maybe limit would be better. > > > > It calculates least fixed points. `fix' is as good a name as any. > > > > `limit' is terrible; the argument to fix, a -> a, is neither a sequence > > nor diagram nor net type, and hence its values don't have limits... > > > > jcc > > > > PS Yes, I know fix a = sup_{i=0}^inf f^i(bot). That sequence is rather > > different than the input function... > > Actually, f :: a -> a -is- a diagram and its limit -is- fix f. In what way? I'm not disputing you, but I don't see how to interpret it as such. > That > said, limit is still a horrible name for it. fix isn't much better, and > Y is even worse. I'm not sure what an immediately intuitive name would > be, so might as well go with the historical one. recursive (at least for my usage). jcc

4 3