- Haskell-Cafe - Haskell.org

AW: How to read an initialization file.
by Markus.Schnell＠infineon.com 14 Mar '03

14 Mar '03

I would recommend reading the variables in the main and pack the rest of your program into a monad. But only if you really need to access the variables from everywhere and don't want to pass them around explicitely. Markus > I need to be able to access these values effieiently and from > virtually anywhere in the program. It would be nice to "at some > point" open the file and read all these variables, all at once.

1 0

Redefining methods in a subCLASS
by Oleg 14 Mar '03

14 Mar '03

Hi Is it possible to redefine methods in a subclass (not an instance)? E.g. I get errors in class (Show a) => Employee a where speak :: a -> [Char] speak x = "Employee: " ++ (show x) class (Employee a) => Manager a where speak x = "Manager: " ++ (show x) Thanks Oleg

1 0

Re: How to search for a string sequence in a file a rewrite it???
by Tom Pledger 13 Mar '03

13 Mar '03

(moving to haskell-cafe) Alexandre Weffort Thenorio writes: | Ooops a small error before but here is the right one. | | Great. I got almost everything. My problem now is: | | I got a function called findstr where | | findstr "aaaa" "zzzzz" ["xxxxaaaa","xxxaaaaxxx"] = | ["xxxxzzzzz","xxxzzzzzxxx"] with the inferred type findstr :: String -> String -> [String] -> [String] | and then I try something like | | fillIn lines = do | bkfilled <- (findstr str str2 lines) with the inferred type (findstr str str2 lines) :: [String] Note that [] (the list data constructor) is a monad. So, this 'do' expression is in the [] monad, where perhaps you intended the IO monad. Computations in the [] monad have the effect of iterating over the elements of lists. So, the bound variable gets the inferred type bkfilled :: String which you've noticed in the error message. | write bkfilled | | where write takes a [String] and concatenates it writing it to a file then. | But I get this error saying: | | Expected Type: [String] | Inferred Type: String | In the first argument of 'write' namelly 'bkfilled' | In a do expection pattern binding: write bkfilled | | Any idea?? I mean bkfilled is supposed to be [String] but it says it is a | String, any idea why??? The smallest code change to fix this is to add a 'return', which will wrap another monad (in this case, IO) around findstr's [String] result... > fillIn lines = do > bkfilled <- return (findstr str str2 lines) > write bkfilled ... but you should be able to simplify that code, using one of the monad laws in http://haskell.org/onlinereport/basic.html#sect6.3.6 Regards, Tom

1 0

Learning Haskell, update
by Arjan van IJzendoorn 13 Mar '03

13 Mar '03

Hi all, I've removed the frequently asked questions box at the bottom. It was unused. Fritz Ruehr made a nice Learning Haskell logo. Thank you, Fritz! NHC is compilable under Windows now, so the remark "no windows version" has been removed. Is there someone who wants to make a more decent language comparison table? If not, I'm thinking of removing it. Many things are said about it already in the comp.lang.functional FAQ. Greetings, Arjan

1 0

Explicit function call
by pavel＠joker.botik.ru 12 Mar '03

12 Mar '03

Hello, How can I make an explicit function call in a "do" sequence? Ex: ... do let a = myFunc ... b = myFunc ... c = "Something else" return c ... As I understand myFunc will not be executed, but I need it... Please, help. -- Pavel Zhbanov

4 5

Alternatives to finalization
by Nick Name 11 Mar '03

11 Mar '03

As the result of a conversation on haskell-gui, I have tried to implement the disallocation of resources when a stream is garbage collected. To explain myself: I have a function f :: IO [a] which returns a lazy stream after allocating some resource to feed it (say installing a callback). I wish that the resource could be disallocated when it's no longer used. I did the obvious implementation with Weak.addFinalizer; results are encouraging but not completely satisfying; the scheme I used is: f = do allocateResource l <- makeTheStream addFinalizer l (disallocateResource) return l The problem is that if no memory is allocated, no garbage collection happens; of course finalization is not guaranteed, as the manual states. Another alternative is to make f return an esplicit "close stream" action: f :: IO ([a],IO ()) Is anyone willing to explain me other alternatives if there are, or to tell me that there aren't? Thanks for attention Vincenzo

4 4

ANNOUNCE: Helium, for Learning Haskell, version 1.1
by Arjan van IJzendoorn 11 Mar '03

11 Mar '03

Dear all, We are proud to announce version 1.1 of Helium. It can be found at the Helium website: http://www.cs.uu.nl/~afie/helium/ Version 1.1 has the following improvements: - An installer for Windows systems for an improved out-of- the-box experience. - A cool Java-based graphical interpreter called Hint written by a student at our institute. It has a nice GUI with colours, toolbar buttons and menu's. The best feature is that it integrates with your favourite editor and you can jump to the exact locations of messages by clicking on them! - New warnings and hints for common mistakes: "sin .3", "X = 5" (see below for examples of messages) - Completely new presentation of type errors with more information - Much improved syntax error messages thanks to a new lexer. And thanks to Parsec we can tell not only what was unexpected, but also what would be legal at that position. - The command-line interpreter is now called 'texthint' to avoid conflicts with hmake's 'hi' (sorry!). TextHint is improved in many ways. For one, it now accepts file paths after :l. Other improvements can be found if you type :? - User manuals for the different tools (helium, hint, texthint) and other helpful information on the Helium website - We've compiled Helium with Oxygen (ghc -O2) and this makes the compiler twice as fast. Great work, GHC people! - One well-placed 'seq' makes Helium another 25% faster. - Very many minor bug fixes - The webpage is simpler, wider and easier to navigate thanks to a road map Have fun! the Helium team -- Examples of Helium messages These messages where generated by typing expressions on the texthint prompt. If you compile a file with these errors you will get exact error locations. Prelude> [(1, 3] Unexpected close bracket ']' Hint: Expecting a close bracket for '(' Prelude> sinn .2 Warning: Function composition (.) immediately followed by number Hint: If a Float was meant, write "0.2" Otherwise, insert a space for readability Undefined variable "sinn" Hint: Did you mean "sin" ? Prelude> map [1..10] even Type error in application expression : map [1 .. 10] even term : map type : (a -> b) -> [a] -> [b] does not match : [Int] -> (Int -> Bool) -> c probable fix : re-order arguments Prelude> let X = 5 in X Left hand side pattern defines no variables Undefined constructor "X" Hint: Use identifiers starting with a lower case letter to define a function or a variable Undefined constructor "X" Prelude> 1+chr '0' Type error in variable expression : chr type : Int -> Char expected type : Char -> Int probable fix : use ord instead

1 0

RE: GHC Error Message.
by Simon Peyton-Jones 10 Mar '03

10 Mar '03

------------------------------------------------------------------------ --------------------------- data AParser String = AP {apapply::([String]->[(String,[String])])} Whoa! You can't declare a data type like that! You must have a type variable after the data type name, thus: data AParser a = AP .... It's an egregious bug that GHC does not reject your data type declaration. After that, all bets are off. Some deeply-wired-in invariant is not being obeyed, and all manner of bad things may happen. Thank you for showing up the bug -- I'll fix it. Simon

1 0

GHC Error Message.
by Mansour Al-Mutairi 09 Mar '03

09 Mar '03

Hi, Could someone please explain to me why the following error message happen: When I load the following code into GHC I get an error message: code: --------------------------------------------------------------------------------------------------- data AParser String = AP {apapply::([String]->[(String,[String])])} instance Monad AParser where return v = AP (\inp -> [(v,inp)]) (AP p) >>= f = AP (\inp -> concat [ apapply (f v) inp1 | (v,inp1) <- p inp]) --------------------------------------------------------------------------------------------------- error: --------------------------------------------------------------------------------------------------- Inferred type is less polymorphic than expected Quantified type variable `b' is unified with another quantified type variable `a' When trying to generalise the type inferred for `>>=' Signature type: forall a1 b1. AParser a1 -> (a1 -> AParser b1) -> AParser b1 Type to generalise: forall a1 b1. AParser a1 -> (a1 -> AParser b1) -> AParser b1 In the instance declaration for `Monad AParser' Failed, modules loaded: none. --------------------------------------------------------------------------------------------------- But when I create the type synonym type Stack = [String] data AParser String = AP {apapply::(Stack -> [(String,Stack)])} and use Stack instead of [String], GHC does not complain??? Thanks. Mansour.

1 0

Re: speedup help
by oleg＠pobox.com 08 Mar '03

08 Mar '03

| comb is only called from here: | sumbn n = sum [ bernoulli i * fromIntegral(comb (n+1) i) | i | <- [0 .. n-1] ] Probably I misunderstand what "bernoulli i" stands for. If it is meant Bernoulli number B_i, http://mathworld.wolfram.com/BernoulliNumber.html then the above expression is quite inefficient. Bernoulli numbers with odd indices are all zero, except B_1, which is -1/2. Therefore, the above expression ought to be written as sumbn n = 1 - (fromIntegral (n+1)%(fromIntegral 2)) + sum [ (b' i) * fromIntegral(comb (n+1) i) | i <- [2,4 .. n-1] ] It appears that you compute the sumbn to obtain B_n from the equality sum [bernoulli i * (comb (n+1) i) | i<-[0..n]] == 0 Have you tried bernoulli n = sum [ (sumib k n) % (k+1) | k<-[1..n]] where sumib k n = sum [ (comb k r) * r^n | r<-[2..k]] - sum [ (comb k r) * r^n | r<-[1,3..k]] the advantage of the latter series is that sumib is an Integer, rather than a rational. The powers of r can be memoized. Here's the code -- powers = [[r^n | r<-[1..]] | n<-[1..]] powers = [1..] : map (zipWith (*) (head powers)) powers -- neg_powers = [[(-1)^r * r^n | r<-[1..]] | n<-[1..]] neg_powers = map (zipWith (\n x -> if n then x else -x) (iterate not False)) powers pascal:: [[Integer]] pascal = [1,1] : map (\line -> zipWith (+) (line++[0]) (0:line)) pascal bernoulli n = sum [ fromIntegral (sumib k n) % fromIntegral (k+1) | k<-[1..n]] sumib:: Int -> Int -> Integer sumib k n = sum $ zipWith (*) (neg_powers!!(n-1)) (tail $ pascal!!(k-1)) This code seems to compute 'bernoulli 82' in less then a second, in Hugs (on a 2GHz Pentium IV).

4 6