- Haskell-Cafe - Haskell.org

Very Basic IO question
by Joe Olivas 03 Mar '07

03 Mar '07

I am VERY new to Haskell, and just getting my feet wet with functional programming in general. I've been going over a few examples online, but I can't figure out the behavior I'm seeing on a very basic example: --- module Main where import System.IO main :: IO () main = do putStrLn "Please enter your name: " name <- getLine putStrLn ("Hello, " ++ name ++ ", how are you?") --- This example works as I would expect. The prompt displays with a new line, the input is entered and echoed: --- Please enter your name: joe Hello, joe, how are you? However, changing 'putStrLn' to 'putStr' does not do what I would expect. The prompt doesn't get displayed until after there is input: --- joe Please enter your name: Hello, joe, how are you? Why does it exhibit this behavior? I'm using a ghc 6.6 built from source from 20070227. The regular 6.6 release had the same behavior. Any help would be greatly appreciated. -Joe -- Using Opera's revolutionary e-mail client: http://www.opera.com/mail/

4 3

Hi I need help for very simple question!
by iliali16 03 Mar '07

03 Mar '07

Hi Haskell People, I have problem implementing one function. I think my idea is write but I have minor mistakes which I cannot get right since I progrem Haskell from very recently. No the function is called intoWords and has to take a string of any size and kind of characters.No I have to produce as output a list of strings.To have a rule which defines an element from the list is the space character which can also be included in the string.So what i think should be smth like. intoWord Hello my name is Smart should produse a list looking like [Hello,my,name,is,Smart] Now I tried to do it recucively to take the string and checks if an element is white space in the list using the isSPace build in function. This is my code please help me if you have any suggestions. Also I don't know how to produce a base case for my recursion. import Char intoWords ::String -> [String] intoWords (x:xs) |isSpace x = intoWords xs |otherwise = xs Thanks in advance for any suggestions. I really want to understand this bloody function couse I've been tring for a week now and I have tried so many ways to produce it that now I am fed up with it and I want to know how should it work since I am curious now. -- View this message in context: http://www.nabble.com/Hi-I-need-help-for-very-simple-question%21-tf3334486.… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

5 4

numeric minimization in Haskell
by Chad Scherrer 03 Mar '07

03 Mar '07

Does anyone know of any Haskell code for numeric minimization? I was thinking conjugate gradient would be good, but at this point I'd be happy with anything. I've found some code written by Tomasz Cholewo at http://ci.uofl.edu/tom/software/Haskell/ but it requires importing his "Arr.lhs" library, which is not publicly available. The only other thing I've been able to dig up is this www.st.cs.ru.nl/papers/1997/serp97-cgfunctional.ps.gz which suggests Haskell is slow for such problems. I suspect this was an implementation issue, so I don't think their code would be very helpful (though it would be nice to tidy it up and demonstrate the improvement - could it beat the Clean implementation they give?) The other possibility I was considering was using Alberto Ruiz's wrapper for the GSL library http://dis.um.es/~alberto/GSLHaskell/ The only problems with this are (1) requires having GSL available, so it's not as portable, and (2) does everything in terms of lists, which requires a lot of translations to and from lists (I'm using mutable arrays). If there's nothing already written that works together, one of these should give me a start, but I'd like to avoid reinventing the wheel if possible. Thanks! -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

5 7

Takusen and strictness
by Paul Moore 02 Mar '07

02 Mar '07

I'm still fiddling with simple database queries using Takusen. One question I have is regarding strictness. I've just been reading "Haskell IO for Imperative Programmers" and loved the idea that laziness (rather than monads) is what makes IO in Haskell so simple. What I'm not sure about, is whether Takusen offers a way of lazily getting data from a database (and a meta-question - how do I work this out for mysefl?!) With the code {-# OPTIONS -fglasgow-exts #-} import Database.Oracle.Enumerator import Database.Enumerator runSql :: String -> IO [String] runSql s = withSession (connect "USER" "PASSWD" "DB") ( do let iter (s::String) accum = result (s : accum) r <- doQuery (sql s) iter [] return r ) main :: IO () main = do r <- runSql "select username from all_users" putStrLn (unlines r) I can do a simple database query, process the results, and produce output. The sreucture of main is much like an interact loop, but with the input from a database rather than stdin. But, will this read the database lazily, or will it get all the rows into memory at once? How will using result' instead of result (in runSql) affect this? And as I said above, how can I learn to work this out for myself? I know I could just ignore the issue until performance becomes a problem and then profile - but that ignores the question of whether I've got the idiom right. Thanks for any help, Paul.

7 9

Re: [Haskell] Laziness and the IO Monad (randomness)
by Kirsten Chevalier 02 Mar '07

02 Mar '07

[redirecting to haskell-cafe] On 3/1/07, Dave Tapley <dukedave(a)gmail.com> wrote: > However this latter case gets stuck in an infinite loop, terminating on a stack overflow. > > My question asks why this is the case, when laziness should ensure only the first 10 cases need to be computed. > You didn't say which function you had narrowed down the stack overflow to, but I suspect it's here: > firstTen :: IO [Int] > firstTen = do > infiniteNums <- iterateM addRand randNum > return (take 10 infiniteNums) In order for IO to work the way you'd expect, you have to be able to specify which IO operations happen in what order, which is exactly what a do-block within the IO monad specifies. But specifying the order of operations also means specifying in what order evaluation happens. So, the code you've written means "evaluate infiniteNums fully (in order that we might do whatever IO operations it involves before the return statement), then return the first 10 elements of its result." Since you're forcing evaluation of an infinite list, the program loops infinitely. If you find this counter-intuitive, you wouldn't be the first, but there's no other sensible interpretation for the code you've written. Deferring evaluation of infiniteNums in this case would mean that IO would happen in a strange and unpredictable order (or if it actually wouldn't, then the compiler isn't smart enough to know that.) I would solve this problem by writing a version of iterateM that takes the length of the desired list as an argument (e.g., 10 in your example), which sadly breaks modularity, but as I explained above, working within the IO monad necessitates that. Someone more l33t than me may be able to suggest a more elegant solution, though. Cheers, Kirsten -- Kirsten Chevalier* chevalier(a)alum.wellesley.edu *Often in error, never in doubt "They killed, they maimed, and they called information for numbers they could easily look up in the book." -- Woody Allen

2 1

splitting strings
by h. 02 Mar '07

02 Mar '07

Hello, I wrote the following split function for Strings: splitS :: String -> String -> [String] splitS a b = splitA a b where z = length b - 1 splitA [] _ = [""] splitA (c:cs) (d:ds) | c == d && fst s == ds = "" : splitA (snd s) b | otherwise = (c : head r) : tail r where r = splitA cs b s = splitAt z cs example: splitS "Test;Hello;+123.5;+ 7" ";+" -> ["Test;Hallo","123.5"," 7"] How could it be optimized on speed? Does there exist already an optimized split for the conventional String type? -- Thanks in advance for your answer. h.

3 3

Using loop fusion for writing efficent high-level code Re[2]: [Haskell] [Fwd: Re: Computer Language Shootout]
by Bulat Ziganshin 02 Mar '07

02 Mar '07

Hello Duncan, Tuesday, February 27, 2007, 1:09:53 PM, you wrote: can you please provide examples of such code? the ultimate goal is to have tutorial on writing efficient code in high-level manner, but that is too ambitious. just some examples with a little explanation of how this is compiled? thanks in advance >> So I think we should do the same. It even shows in the Shootout - the >> programs that are simultaneously fastest and clearest are not pure >> Haskell, but delegate their innermost loops to tuned C libraries (FPS >> and GMP). > I should note that FPS is almost completely Haskell code, not C. We use > C for things like memcmp, memcpy, memset, reverse_copy, intersperse, > maximum, minimum and count. > Certainly some of the innards are low level style Haskell, though not > the kind that could be replicated in C because we use high level > transformations to fuse loop bodies together and wrap them in high > performance, low level loop code. > This is not the style where we just wrap well tuned C code, this is a > style where we generate high performance low level code from a high > level spec. This relies on GHC's excellent and programmable optimiser. > It's wrong to say that the shootout improvements were only down to > improved libraries. The performance of ByteString code improved very > significantly between GHC 6.4 and 6.6 and a large part of that was down > to optimiser improvements (not just the ForeignPtr rep change). Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

5 7

Re: [Haskell-cafe] Re: OO Design in Haskell
by P. R. Stanley 02 Mar '07

02 Mar '07

>Hi > >>forgive my ignorance but I thought functional programming was a >>mathematically sound framework unlike Object Oriented programming. > >Referentially transparent is a better term than mathematically sound >here. This is the property that x = y means that instances of x can be >replaced with y. >Could you elaborate please? >>Isn't using Haskell for OOP kind of defeating the whole object? > >It is defeating the point of expressing programs in a beautiful way, >but if you are building it on top of Haskell, without going to things >like unsafePerformIO, then you still end up with a referentially >transparent framework. I suppose one thing OO has going for it is a useful system of organising your code. Beyond that I'm afraid it is open to the same issues which plagued the soft eng world in the 70s. Yet, everyone seems to be mad about it inthe business. Sorry if this is going slightly off-topic. Paul

1 0

Build failed - hidden package ?
by Dunric 02 Mar '07

02 Mar '07

Hi. I've got stuck with the following compilation error I probably can't fully understand: ---------------------------------------------------------------------- Building library... ... Using package config file: /usr/local/lib/ghc-6.6/package.conf wired-in package base mapped to base-2.0 wired-in package rts mapped to rts-1.0 wired-in package haskell98 mapped to haskell98-1.0 wired-in package template-haskell mapped to template-haskell-2.0 Hsc static flags: -static ... Graphics/UI/SDL/Rotozoomer.hs:15:7: Could not find module `Foreign.C': it is a member of package base, which is hidden ---------------------------------------------------------------------- What does such error mean ? Modules Foreign and Foreign.C are installed and available from the default path. Lines 12-15 of Rotozoomer.hs: ------------------------------------------ module Graphics.UI.SDL.Rotozoomer where import Foreign import Foreign.C ------------------------------------------ Any idea what's wrong, resp. some explanation why compilation fails ? Thanks in an advance. ------------------------------------------ www.icqsms.cz

2 1

Re: [Haskell-cafe] Re: OO Design in Haskell Example (Draft)
by Tim Docker 01 Mar '07

01 Mar '07

"Steve Downey" <sdowney(a)gmail.com> wrote: > I'm not sure, though, what would happen if I tried to > add state to the types. With the previous example, > using existentials to create a reference type that > holds elements of a type class that matches the interface, > I think that it would be natural to hold state by having > that element stored in a mutable state variable, and replacing > the held values. State is often best avoided, but if it's really what you want to do, you can still capture a mutable variable in the closures captured inside the record of functions. Tim import Data.IORef data Component = Component { draw :: IO (), move :: (Int,Int) -> IO () } newCircle :: IO Component newCircle = do pref <- newIORef (0,0) return Component{draw=draw' pref, move=move' pref} where draw' pref = do p <- readIORef pref putStrLn ("circle at " ++ show p) move' pref p = writeIORef pref p

3 2