- Haskell - Haskell.org

RE: readFloat
by Simon Peyton-Jones 30 May '02

30 May '02

| It would be strange to name a function readFloat if its type is | RealFrac a => ReadS a. | I think the function should be named readFrac. For | compatibility, one could put the following into the prelude: | readFloat :: RealFloat a => ReadS a | readFloat = readFrac Well, that would be possible, but there are other naming inconsistencies in the Prelude; indeed, even in the numeric library. My inclination is to put up with the inconsistency. You have to look up the type to use it anyhow. Simon

1 0

��ȫ��ͼ�
by raeline 29 May '02

29 May '02

您好，很冒味的给你来信。希望我的来信会给您带来方便。专业的域名主机服务商为您提供超低价，高速，安全，稳定的主机服务。 30M主机只需198元。还送国际域名及邮箱。功能：支持CGI PHP MYSQL SQL，ACCESS ASP 50M 、100M 、200M 详情请看：http://www.raeline.net 全国最低价的代理价格。咨询QQ：16559573 可以索取代理价格表。全国最稳定,可玩性最好。人气最旺的江湖：http://www.xajh.com.cn 郑重承诺：主机使用不满意，我们按实际使用时间退款。 TEL：0592-2281881-29 (肖先生) FAX：0592-2682299 瑞来网络技术(厦门)有限公司使用极星邮件群发，无须通过邮件服务器，直达对方邮箱，速度绝对一流！下载网址：http://www.lovexin.com，更多免费的超酷软件等你来下…… ---------------------------------------------------- INFORMATION This message has been sent using a trial-run version of the TSmtpRelayServer Delphi Component. ----------------------------------------------------

1 0

Re: GMP from haskell
by Serge D. Mechveliani 29 May '02

29 May '02

> Hal Daume III <hdaume(a)ISI.EDU> writes: > > The gnu web page > (www.gnu.org/manual/gmp-4.0.1/html_node/gmp_70.html) claims that Haskell > (GHC) has bindings to GMP. Is this true? How can I access these > routines? Some Haskell systems mention that they use GMP to implement many functions for Integer. There are open-source libraries: GMP, and some others (do not remember the names), written in C, implementing a lot of mathematics, advanced algorithms and programs designed by expert mathematicians, like say Lenstra. For example, the factorization function for Integer, and useful functions for algebraic numbers (if I recall correct) are available, not only for Integer. The advantage is also that these methods win many times in comparison to what the naive user writes in several lines of one's Haskell program. If the Haskell implementors take care of mathematician users, they could consider the possibility to arrange the interface to these functions and thus extend the library with many useful operations items (mainly, not of Haskell-98 standard). ----------------- Serge Mechveliani mechvel(a)botik.ru

1 0

New lectureship in Nottingham
by Graham Hutton 29 May '02

29 May '02

Dear all, We are currently advertising a new lectureship in Nottingham. There are no particular research areas specified for this position, but applications in the area of the Foundations of Programming research group (http://www.cs.nott.ac.uk/Research/fop/) would be most welcome. Further details about the position is available from: http://www.nottingham.ac.uk/personnel/vacancies/academic.html#RUB/457S The closing date for applications is 14th June 2002. Graham Hutton +----------------------------------------------------------------------------+ | Dr Graham Hutton Email : gmh(a)cs.nott.ac.uk | | Foundations of Programming Group Web : http://www.cs.nott.ac.uk/~gmh | | School of Computer Science and IT | | University of Nottingham | | Jubilee Campus, Wollaton Road | | Nottingham NG8 1BB Phone : +44 (0)115 951 4220 | | United Kingdom Fax : +44 (0)115 951 4254 | +----------------------------------------------------------------------------+

1 0

fold on Monad?
by Jon Fairbairn 29 May '02

29 May '02

Suppose I have a task I want to do to each line of a file, accumulate a result and output it, I can write main = do stuff <- getContents print $ foldl process_line initial_value (lines stuff) ie, it's obviously a fold I can't see a way of doing the same thing directly on the IO: I'd like to write something similar to main = do res <- foldX process_line initial_value getLine print res foldM almost does it: main = do res <- foldM process initial_value (repeat getLine) print res process a g = do line <- g return (process_line a line) but that goes on forever (or some fixed amount if (replicate n/repeat)) I feel this ought to be straightforward -- the structure is obviously some sort of fold, but I shouldn't have to use a list -- so I must be missing something obvious. What is it? Jón -- Jón Fairbairn Jon.Fairbairn(a)cl.cam.ac.uk 31 Chalmers Road jf(a)cl.cam.ac.uk Cambridge CB1 3SZ +44 1223 570179 (after 14:00 only, please!)

1 0

readFloat
by Simon Peyton-Jones 28 May '02

28 May '02

Folks I'm back to tidying up the Haskell Report. In the Numeric library, there is the useful function readFloat :: RealFloat a => ReadS a But you can't use it for reading rationals, because Rational isn't in RealFloat! This is a Royal Pain, and entirely unnecessary. In fact, readFloat uses only operations from the RealFrac class, so it could equally well have type readFloat :: RealFrac a => ReadS a I'm strongly inclined to make this change. It breaks no programs, and it fixes a real bug i.e. there is no way to read a "103" as a Rational. Simon

1 0

Efficient way to code "(symbol,multiplicity)-counting" - how?
by Mark Phillips 28 May '02

28 May '02

Hi, I am new to Haskell and am having some difficulty with the following problem. Suppose I have a list of "symbols", except that each symbol is paired with a "multiplicity". Ie, we have a list of type [(a,Int)]. I want to use these symbols to "count". Let me explain what I mean by count with the following example. Suppose we have symbol list [(x,1),(y,2),(z,1)]. This tells us that * we have three symbols, namely x, y and z * the symbols are ordered, namely x < y < z * with any "counting figure" the symbol x may appear at most once, the symbol y at most twice and the symbol z at most once (a "counting figure" is just a list of symbols, these symbols forming the "digits") * any "counting figure" will have between 0 and 1+2+1=4 "digits" (symbols) * the "counting figures" are ordered; the fewer the number of "digits" the "smaller" the figure; for figures with the same number of digits ordering is based on the symbol ordering, the left-most digit being "most significant", second-left being "second-most significant" and so on. We "count" as follows: [] [x] [y] [z] [x,y] [x,z] [y,x] [y,y] [y,z] [z,x] [z,y] [x,y,y] [x,y,z] [x,z,y] [y,x,y] [y,x,z] [y,y,x] [y,y,z] [y,z,x] [y,z,y] [z,x,y] [z,y,x] [z,y,y] [x,y,y,z] [x,y,z,y] [x,z,y,y] [y,x,y,z] [y,x,z,y] [y,y,x,z] [y,y,z,x] [y,z,x,y] [y,z,y,x] [z,x,y,y] [z,y,x,y] [z,y,y,x] and then start back at the beginning again (with []). I want to define a function next :: [(a,Int)] -> [a] -> [a] which finds the next list in the the "counting sequence". So for example we should get next [(x,1),(y,2),(z,1)] [] == [x] next [(x,1),(y,2),(z,1)] [z,y] == [x,y,y] next [(x,1),(y,2),(z,1)] [x,y,y,z] == [x,y,z,y] next [(x,1),(y,2),(z,1)] [z,y,y,x] == [] etc My question is, what is the best way to code this in Haskell? Can it be done efficiently? Also, is my representation of symbols and multiplicities the best method? Would I be better to represent them as two lists say, and in reverse order say: ie [z,y,x] and [1,2,1]. Or is there another better way to frame the whole problem? Cheers, Mark. -- Dr Mark H Phillips Research Analyst (Mathematician) AUSTRICS - Smarter Scheduling Solutions - www.austrics.com Level 2, 50 Pirie Street, Adelaide SA 5000, Australia Phone +61 8 8226 9850 Fax +61 8 8231 4821 Email mark(a)austrics.com.au

3 5

Huffman algorithm
by matush23＠netscape.net 28 May '02

28 May '02

Hi, I have problems with assignation of types, I did this ... ***** End: -- Codigo de Huffman The rest of the message is ignored: > -- > -- > -- Un arbol binario comun > -- > data BinTree a = Hoja a > | Nodo (BinTree a) (BinTree a) > > type Huff = BinTree Char > > -- Arbol especifico para la funcion `combinar' > -- > data Tree = Leaf Int Char > | Node Int Tree Tree > > -- Binary search tree para la funcion `freqs' > -- > data BSTree a = Nil | BSNode a (BSTree a) (BSTree a) > > > > -- Calculo de las frequencias de cada letra > -- > freq :: BSTree (Char,Int) -> String -> BSTree (Char,Int) > freq t [] = t > freq t (x:xs) = insertTree x (freq t xs) > > insertTree :: Char -> BSTree (Char,Int) -> BSTree (Char,Int) > insertTree x Nil = BSNode (x,1) Nil Nil > insertTree x (BSNode (c,n) t1 t2) | x==c = BSNode (c,n+1) t1 t2 > | x<c = BSNode (c,n) (insertTree x t1) t2 > | x>c = BSNode (c,n) t1 (insertTree x t2) > > flatten :: BSTree a -> [a] > flatten Nil = [] > flatten (BSNode x t1 t2) = [x] ++ (flatten t1) ++ (flatten t2) > > iSort :: [(Char,Int)] -> [(Char,Int)] > iSort [] = [] > iSort (x:xs) = ins x (iSort xs) > > ins :: (Char,Int) -> [(Char,Int)] -> [(Char,Int)] > ins a [] = [a] > ins a@(c,n) l@((d,m):xs) | n<=m = a:l > | otherwise = (d,m):ins a xs > > freqs :: String -> [(Char,Int)] > freqs xs = (iSort . flatten) (freq Nil xs) > > > > -- Decodificacion > -- > decodificar :: [Int] -> Huff -> String > decodificar xs t = aux xs t t > where aux [] (Hoja c) t = [c] > aux (x:xs) (Hoja c) t = [c] ++ aux (x:xs) t t > aux (0:xs) (Nodo t1 t2) t = aux xs t1 t > aux (1:xs) (Nodo t1 t2) t = aux xs t2 t > > > > -- Codificacion respecto a un arbol dado > -- > cod :: Char -> Huff -> [Int] > cod c t = head (aux c t) > where aux c (Hoja d) | c==d = [[]] > | otherwise = [] > aux c (Nodo t1 t2) = [ (0:xs) | xs <- aux c t1 ] ++ > [ (1:xs) | xs <- aux c t2 ] > > codificar :: String -> Huff -> [Int] > codificar xs t = concat (map (\c->cod c t) xs) > > > > > --Construccion del arbol de Huffman > -- > combinar :: [Tree] -> [Tree] > combinar [t] = [t] > combinar (t1:t2:ts) = insert (Node (w1+w2) t1 t2) ts > where weight (Leaf n x) = n > weight (Node n _ _) = n > insert t [] = [t] > insert t (u:us) | weight t < weight u = t:u:us > | otherwise = u:(insert t us) > w1 = weight t1 > w2 = weight t2 > > combinarTodos :: [Tree] -> Tree > combinarTodos [t] = t > combinarTodos ts = combinarTodos (combinar ts) > > > > -- Pegamos la construccion del arbol y la codificacion del texto > -- > codificarTexto :: String -> ([Int], Huff) > codificarTexto xs = (ys, t) > where ls = freqs xs > desmarcar (Leaf n x) = Hoja x > desmarcar (Node n t1 t2) = Nodo (desmarcar t1) (desmarcar t2) > t = (desmarcar . combinarTodos) (map (\(c,n)->Leaf n c) ls) > ys = codificar xs t > > > > > -- Example > -- > prueba1 = let (s, t) = codificarTexto "Salvete, omnes" > in decodificar s t > > > > "Please, I need help. __________________________________________________________________ Your favorite stores, helpful shopping tools and great gift ideas. Experience the convenience of buying online with Shop@Netscape! http://shopnow.netscape.com/ Get your own FREE, personal Netscape Mail account today at http://webmail.netscape.com/

1 0

ANN: Functional Metapost 1.2
by Ferenc Wagner 28 May '02

28 May '02

Dear Haskell Community, version 1.2 of Functional Metapost is now available at http://afavant.elte.hu/~wferi/funcmp/ News: * This version includes English translations of the most important parts of the documentation! Thanks to Meik Hellmund, who contributed the translations. * 8-bit color depth bitmaps work. Cheers, Feri.

3 4

RE: Negative literals and the meaning of case -2 of -2 -> True
by Simon Peyton-Jones 27 May '02

27 May '02

Fixed. Simon | -----Original Message----- | From: Simon Marlow [mailto:simonmar@microsoft.com] | Sent: 17 May 2002 10:34 | To: Thomas Hallgren; haskell(a)haskell.org | Subject: RE: Negative literals and the meaning of case -2 of | -2 -> True | | | | > To find out how Haskell implementations treat negated | > literals, I tested | > the following program: | > | > ------------------------------------------------ | > main = print (minusTwo,trueOrFalse) | > | > minusTwo = -2::N | > | > trueOrFalse = | > case minusTwo of | > -2 -> True | > _ -> False | > | > data N = Negate N | FromInteger Integer deriving (Eq,Show) | > | > instance Num N where | > negate = Negate | > fromInteger = FromInteger | > ------------------------------------------------- | > | > The result is: | > | > * ghc 5.02.2: main outputs: (FromInteger (-2),True) | | GHC has two bugs in this area, one of which has been fixed | recently. The current output is (Negate (FromInteger | 2),False) (i.e. the same as hbc). We were being a little too | eager to replace 'negate (fromInteger N)' by 'fromInteger | (-N)'. There is also a bug in the pattern handling, however. | | Thanks for a nice test case... | | Cheers, | Simon | | _______________________________________________ | Haskell mailing list | Haskell(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell |

1 0