May 2009 - Haskell-Cafe

ANN: EsotericBot 0.0.1
by spoon＠killersmurf.com 21 May '09

21 May '09

Hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/esotericbot See the homepage for online copy of README and example configuration file: http://www.killersmurf.com/projects/esotericbot Esotericbot is a sophisticated, lightweight IRC bot, written in Haskell. Esotericbot launches sub-processes to respond to commands issued by users over IRC. Why would you use esotericbot? For lambdabot-4.2.2.1: spoon@utensil:~/esotericbot$ ps e v PID TTY STAT TIME MAJFL TRS DRS RSS %MEM COMMAND 23433 pts/3 Sl+ 0:00 0 8228 84855 33476 1.6 lambdabot 15040 pts/5 S+ 0:00 0 2171 28804 3292 0.1 ./esotericbot I'm not insinuating that lambdabot sucks in any way, ( for lambdabot is most excellent ) however, my hope is that esotericbot could attain equal functionality through plugins, whilst maintaining its small memory footprint. Esotericbot is small, designed to run on a server with limited memory - typically running at under 5mb of private memory. Features: * Advanced memory and time management options, utilizing POSIX resource management. For example, the memory used by all child processes, can be limited - commands be queued until the memory usage has dropped. * Privileged channel operator commands ( Currently, can be disabled and enabled by channel operators, without kicking. ) * Easy to add new plugins. A C library is included to make writing new plugins/adapting programs in C easy. * Set up through a configuration file. * Multiple channels. * Multi-threaded * Lightweight, typically running at under 5mb of private memory. Cons: * POSIX memory management, process forking, and chroot means that Esotericbot is POSIX only. * Esotericbot is, due to the libraries and extensions used, restricted to being compiled by the Glorious Glasgow Haskell Compiler.

2 1

ghc ./configure stalls on docbook DTD
by Dan 21 May '09

21 May '09

Hi, Not sure if this is the right place to ask. GHC 6.10.3 source dist: ./configure takes about 10 minutes to look for DocBook DTD and another 10 to look for DocBook XSL directory. I was writing this e-mail thinking it had completely crashed. Any reason why it's so ridiculously slow? A look at 'top' says the CPU is mostly idle during this time, but xmllint is running. Mac OS X uname -a: Darwin 9.6.0 Darwin Kernel Version 9.6.0: Mon Nov 24 17:37:00 PST 2008; root:xnu-1228.9.59~1/RELEASE_I386 i386 CookBook:ghc-6.10.3 dan$ ./configure checking build system type... i386-apple-darwin9.6.0 checking host system type... i386-apple-darwin9.6.0 checking target system type... i386-apple-darwin9.6.0 Canonicalised to: i386-apple-darwin [blah blah blah] checking for xmllint... /usr/bin/xmllint checking for DocBook DTD... (blocks for ages)

4 3

what's the definition of "satisfy" and "<?>" ?
by z_axis＠163.com 21 May '09

21 May '09

I cannot understand the following code very well as i donot know the definition of "satisfy" and "<?>". -- | Case-insensitive variant of Parsec's 'char' function. caseChar :: Char -> GenParser Char a Char caseChar c = satisfy (\x -> toUpper x == toUpper c) -- | Case-insensitive variant of Parsec's 'string' function. caseString :: String -> GenParser Char a () caseString cs = mapM_ caseChar cs <?> cs Would somebody mind to explain the code in detail ? Sincerely!

3 2

Re: [Haskell-cafe] showing a user defined type
by michael rice 21 May '09

21 May '09

Thanks for the extra patience. What does "unsafe" mean? From my perspective, you had a perfectly good chain_take function fun chain_take(0,_) = nil | chain_take(n,Link(i,f)) = i :: chain_take(n-1,f(i)) - chain_take(5,always1(6)); val it = [1,1,1,1,1] : int list Putting aside weird_chain_take for now, what, if anything, is unsafe about chain_take? Michael --- On Wed, 5/20/09, Ryan Ingram <ryani.spam(a)gmail.com> wrote: From: Ryan Ingram <ryani.spam(a)gmail.com> Subject: Re: [Haskell-cafe] showing a user defined type To: "michael rice" <nowgate(a)yahoo.com> Cc: "Brandon S. Allbery KF8NH" <allbery(a)ece.cmu.edu>, haskell-cafe(a)haskell.org Date: Wednesday, May 20, 2009, 2:21 PM Actually, I was saying that "chain" already emulates laziness, just in a somewhat unsafe way, as demonstrated by weird_take. In Haskell you'd probably just write > ints :: Int -> [Int] > ints n = [n..] and be done with it. -- ryan On Wed, May 20, 2009 at 9:41 AM, michael rice <nowgate(a)yahoo.com> wrote: > OK, I think I understand. You were explaining how ML could be made to > emulate Haskell laziness using streams, ala Scheme type delayed evaluation, > so it's kind of like you were explaining a question I hadn't quite asked > yet, which maybe explains my puzzlement, I hope. > > Also, though my understanding of both Haskell and ML syntax is still > rudimentary, I did catch an error in your definition of chain_take: the > first arg of the cons should be i rather than n. > > I'm still going through your code and may have further questions. > > Thanks for your input. > > Michael > > > --- On Wed, 5/20/09, Ryan Ingram <ryani.spam(a)gmail.com> wrote: > > From: Ryan Ingram <ryani.spam(a)gmail.com> > Subject: Re: [Haskell-cafe] showing a user defined type > To: "michael rice" <nowgate(a)yahoo.com> > Cc: "Brandon S. Allbery KF8NH" <allbery(a)ece.cmu.edu>, > haskell-cafe(a)haskell.org > Date: Wednesday, May 20, 2009, 4:12 AM > > (Apologies for my mutilation of ML syntax, I don't completely know the > language) > > Consider the ML type int list, and this function to build one: > > broken_repeat :: int -> int list > broken_repeat n = Cons(n, broken_repeat(n)) > > This function is recursive, and doesn't terminate; it tries to build > an infinite list of ints and your computer runs out of heap and/or > stack trying to evaluate it. > > But the "chain" type doesn't have this problem; you can see it as an > int list that gets evaluated "on demand": > > repeat :: int -> chain > repeat(n) = Link(n, repeat) > > always1 :: int -> chain > always1(_) = Link(1, always1) > > chain_take :: int * chain -> int list > chain_take (0,_) = Nil > chain_take (n,Link(i,f)) = Cons(n, chain_take(n-1, f(i))) > > But, nothing in the "chain" type stops you from passing a different > value to the function in the link: > > weird_take :: int * int * chain -> int list > weird_take (0,_,_) = Nil > weird_take (n,v,Link(i,f)) = Cons(i, weird_take(n-1,v,f(v))) > > Now, it's possible that chain_take returns the same list for two > different "chain" inputs, but weird_take might return different lists > depending on how f is implemented. For example: > chain_take(5, repeat(1)) = [1,1,1,1,1] > chain_take(5, always1(1) = [1,1,1,1,1] > > weird_take(5, 2, repeat(1)) = [1,2,2,2,2] > weird_take(5, 2, always1(1)) = [1,1,1,1,1] > > One way to fix this is to embed the "state" of the chain in the closure > itself. > > So, in ML, the type > unit -> X > is commonly called a "thunk"; it can be used to delay computation > until later, until it's demanded, just like any lazy value in Haskell. > > f :: unit -> Int > f () = 1 > > This f isn't very useful; it's basically the same as "1". But > consider this type: > > datatype stream = Stream of (int * (unit -> stream)) > > stream1 () = Stream(1, stream1) > > stream_take :: int*stream -> int list > stream_take(0,_) = Nil > stream_take(n,Stream(i,f)) = Cons(i, stream_take(n-1, f())) > > Now there is no way to pass a different value like we did in > weird_take; there's only (). > > The difference is that the state gets embedded in the closure for the thunk: > > stream_ints :: int -> (unit -> stream) > stream_ints = fun n => fun () => Stream(n, stream_ints(n+1)) > > What you are doing here is encoding laziness; the Haskell version of this > type: > >> data Stream = Stream !Int Stream -- !Int means the Int value is strict >> stream1 = Stream 1 stream1 >> stream_ints n = Stream n (stream_ints(n+1)) > >> stream_take :: Int -> Stream -> [Int] >> stream_take 0 _ = [] >> stream_take n (Stream x xs) = x : stream_take (n-1) xs > > No extra (\() -> ...) thunk is required, due to laziness :) > > -- ryan > > On Tue, May 19, 2009 at 4:25 PM, michael rice <nowgate(a)yahoo.com> wrote: >> Hi Ryan, >> >> I'm afraid you've lost me. Maybe if you showed how this would be used in >> ML >> I would get the picture. >> >> Michael >> >> --- On Tue, 5/19/09, Ryan Ingram <ryani.spam(a)gmail.com> wrote: >> >> From: Ryan Ingram <ryani.spam(a)gmail.com> >> Subject: Re: [Haskell-cafe] showing a user defined type >> To: "michael rice" <nowgate(a)yahoo.com> >> Cc: "Brandon S. Allbery KF8NH" <allbery(a)ece.cmu.edu>, >> haskell-cafe(a)haskell.org >> Date: Tuesday, May 19, 2009, 2:40 PM >> >> On Tue, May 19, 2009 at 7:07 AM, michael rice <nowgate(a)yahoo.com> wrote: >>> A little further along in "The Little MLer" the ints function is replaced >>> by >>> other functions like primes and fibs, which also return Links: >>> >>> fun primes(n) >>> = if is_prime(n+1) >>> then Link(n+1,primes) >>> else primes(n+1) >>> >>> fun fibs(n)(m) >>> = Link(n+m,fibs(m)) >>> >>> which are passed to chain_item: >>> >>> fun chain_item(n,Link(i,f)) >>> = if eq_int(n,1) >>> then i >>> else chain_item(n-1,f(i)) >>> >>> which can be called to request the nth (12th) prime number beginning at >>> 1. >>> >>> - chain_item(12,primes(1)); >>> GC #0.0.0.1.3.61: (1 ms) >>> val it = 37 : int >>> - >>> >>> So I guess the answer to your question about whether the function is ever >>> called with a different value may be, yes. >> >> Actually, it's not calling it with another value; notice that >> chain_item calls f(i), with i coming directly from the chain. >> Consider this alternate definition: >> (I'm not sure the syntax is exactly right, but you get the idea) >> >> datatype chain = >> Link of (int * ( unit -> chain )) >> >> fun intsFrom(n) = fun unit => (n, intsFrom (n+1)) >> fun ints(n) = intsFrom n () >> >> Now you *can't* call the function embedded in the link with another value. >> >> fun chain_item(n,Link(i,f)) >> = if eq_int(n,1) >> then i >> else chain_item(n-1,f unit) >> >> And this type for "chain" is almost the same as [Int] in Haskell, due >> to laziness. >> >> -- ryan >> >> > >

2 1

Tree traversal / stack overflow
by Matthew Eastman 20 May '09

20 May '09

Hi, I've been writing some code to calculate the stretch factor of a tree of points. What it means is that for every node in a tree (lets call it 'pivot'), I have to traverse the same tree (lets call each node 'current') and sum d_t(pivot, current) / d(pivot, current) for each node, where d_t is the tree path distance between two nodes and d is the Euclidean distance. What I've been doing is traversing the tree, pivoting up each node into the root position, and calculating the stretch factor for each new tree. ex. +===+ +===+ +===+ | 1 | | 2 | | 3 | +===+ .---+===+----. +===+ / / | | \ \ +---+ +---+ +---+ +---+ +---+ +---+ | 2 | ---> | 3 | | 4 | | 5 | | 1 | ---> | 2 | etc. .+---+. +---+ +---+ +---+ +---+ .+---+. / | \ / | \ +---+ +---+ +---+ +---+ +---+ +---+ | 3 | | 4 | | 5 | | 4 | | 5 | | 1 | +---+ +---+ +---+ +---+ +---+ +---+ The code I have right now works great on point sets of size ~10,000, but when I go up much higher things start to go wrong. I start hitting stack overflows, so I increased the stack size. For ~100,000 points though, running the code with +RTS -sstderr -K128m it chugged along for over an hour and then died with a stack overflow. The stats said it spent 50 seconds MUT time and 5300 seconds (almost 90 minutes!) GC time, which seems odd. The performance has been really good for lower numbers of points, but the professor I'm working for wants to handle over a million points later on. I've only been writing Haskell for a year, and I'm not quite sure how to rewrite this so that it won't blow the stack, since I'm pretty sure this kind of tree traversal can't be done with tail calls (I would love to proved wrong, though!). Any help would be appreciated. Thanks, Matt module ASF ( averageStretchFactor ) where import Data.Tree import Data.Foldable (foldr') type Point = (Double,Double) square :: Double -> Double square x = x * x dist :: Point -> Point -> Double dist (x1,y1) (x2,y2) = sqrt (square (x2 - x1) + square (y2 - y1)) add :: Tree a -> Tree a -> Tree a add (Node p sts) t = Node p (t:sts) -- Calculate the average stretch factor of a tree of size n. It's the sum of -- the average stretch factor of each node in the tree, divided by n choose 2 -- (the number of possible pairs of points in in a tree of size n) averageStretchFactor :: Tree Point -> Double -> Double averageStretchFactor tree n = stretchRotations tree / (n * (n - 1) / 2) -- Calculate the stretch factor of a tree. -- The stretch of two points is the tree path distance between the two points -- divided by the euclidean distance between the two points. The stretch factor -- of a tree is the sum of the stretches between the root and every other node -- in the tree. stretchFactor :: Tree Point -> Double stretchFactor (Node point sts) = stretch 0 point sts where stretch _ _ [] = 0 stretch d p ((Node p' sts'):ts) = pd / ed + stretch pd p' sts' + stretch d p ts where pd = d + dist p p' -- path distance ed = dist point p' -- euclidean distance -- Calculate the stretch factor of every point by pulling up each node in the -- tree to the root position. Note that the overall structure of the tree -- doesn't change, we're essentially just traversing the tree and calculating -- the stretch factor of each node by pretending we're at the root. stretchRotations :: Tree Point -> Double stretchRotations tree = rotate tree [] where rotate tree@(Node p sts) path = stretchFactor (foldr' add tree path) + pivot [] sts path p pivot _ [] _ _ = 0 pivot ls (r:rs) path p = rotate r (Node p (ls ++ rs) : path) + pivot (r:ls) rs path p ./main 10000 +RTS -sstderr -K128m ASF = 22.441 1,298,891,896 bytes allocated in the heap 20,191,904 bytes copied during GC 3,107,116 bytes maximum residency (7 sample(s)) 47,480 bytes maximum slop 8 MB total memory in use (0 MB lost due to fragmentation) Generation 0: 2471 collections, 0 parallel, 0.06s, 0.07s elapsed Generation 1: 7 collections, 0 parallel, 0.03s, 0.03s elapsed INIT time 0.00s ( 0.00s elapsed) MUT time 13.05s ( 13.18s elapsed) GC time 0.09s ( 0.11s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 13.14s ( 13.29s elapsed) %GC time 0.7% (0.8% elapsed) Alloc rate 99,506,082 bytes per MUT second Productivity 99.3% of total user, 98.2% of total elapsed ./main 100000 +RTS -sstderr -K128m Stack space overflow: current size 128000000 bytes. Use `+RTS -Ksize' to increase it. 33,097,322,168 bytes allocated in the heap 3,004,248,280 bytes copied during GC 704,391,196 bytes maximum residency (29 sample(s)) 67,420,196 bytes maximum slop 1731 MB total memory in use (14 MB lost due to fragmentation) Generation 0: 62561 collections, 0 parallel, 5364.16s, 5619.83s elapsed Generation 1: 29 collections, 0 parallel, 4.50s, 48.73s elapsed INIT time 0.00s ( 0.00s elapsed) MUT time 49.85s ( 78.94s elapsed) GC time 5368.66s (5668.56s elapsed) EXIT time 0.00s ( 7.88s elapsed) Total time 5418.51s (5747.56s elapsed) %GC time 99.1% (98.6% elapsed) Alloc rate 663,930,946 bytes per MUT second Productivity 0.9% of total user, 0.9% of total elapsed

1 1

Re: [Haskell-cafe] showing a user defined type
by michael rice 20 May '09

20 May '09

OK, I think I understand. You were explaining how ML could be made to emulate Haskell laziness using streams, ala Scheme type delayed evaluation, so it's kind of like you were explaining a question I hadn't quite asked yet, which maybe explains my puzzlement, I hope. Also, though my understanding of both Haskell and ML syntax is still rudimentary, I did catch an error in your definition of chain_take: the first arg of the cons should be i rather than n. I'm still going through your code and may have further questions. Thanks for your input. Michael --- On Wed, 5/20/09, Ryan Ingram <ryani.spam(a)gmail.com> wrote: From: Ryan Ingram <ryani.spam(a)gmail.com> Subject: Re: [Haskell-cafe] showing a user defined type To: "michael rice" <nowgate(a)yahoo.com> Cc: "Brandon S. Allbery KF8NH" <allbery(a)ece.cmu.edu>, haskell-cafe(a)haskell.org Date: Wednesday, May 20, 2009, 4:12 AM (Apologies for my mutilation of ML syntax, I don't completely know the language) Consider the ML type int list, and this function to build one: broken_repeat :: int -> int list broken_repeat n = Cons(n, broken_repeat(n)) This function is recursive, and doesn't terminate; it tries to build an infinite list of ints and your computer runs out of heap and/or stack trying to evaluate it. But the "chain" type doesn't have this problem; you can see it as an int list that gets evaluated "on demand": repeat :: int -> chain repeat(n) = Link(n, repeat) always1 :: int -> chain always1(_) = Link(1, always1) chain_take :: int * chain -> int list chain_take (0,_) = Nil chain_take (n,Link(i,f)) = Cons(n, chain_take(n-1, f(i))) But, nothing in the "chain" type stops you from passing a different value to the function in the link: weird_take :: int * int * chain -> int list weird_take (0,_,_) = Nil weird_take (n,v,Link(i,f)) = Cons(i, weird_take(n-1,v,f(v))) Now, it's possible that chain_take returns the same list for two different "chain" inputs, but weird_take might return different lists depending on how f is implemented. For example: chain_take(5, repeat(1)) = [1,1,1,1,1] chain_take(5, always1(1) = [1,1,1,1,1] weird_take(5, 2, repeat(1)) = [1,2,2,2,2] weird_take(5, 2, always1(1)) = [1,1,1,1,1] One way to fix this is to embed the "state" of the chain in the closure itself. So, in ML, the type unit -> X is commonly called a "thunk"; it can be used to delay computation until later, until it's demanded, just like any lazy value in Haskell. f :: unit -> Int f () = 1 This f isn't very useful; it's basically the same as "1". But consider this type: datatype stream = Stream of (int * (unit -> stream)) stream1 () = Stream(1, stream1) stream_take :: int*stream -> int list stream_take(0,_) = Nil stream_take(n,Stream(i,f)) = Cons(i, stream_take(n-1, f())) Now there is no way to pass a different value like we did in weird_take; there's only (). The difference is that the state gets embedded in the closure for the thunk: stream_ints :: int -> (unit -> stream) stream_ints = fun n => fun () => Stream(n, stream_ints(n+1)) What you are doing here is encoding laziness; the Haskell version of this type: > data Stream = Stream !Int Stream -- !Int means the Int value is strict > stream1 = Stream 1 stream1 > stream_ints n = Stream n (stream_ints(n+1)) > stream_take :: Int -> Stream -> [Int] > stream_take 0 _ = [] > stream_take n (Stream x xs) = x : stream_take (n-1) xs No extra (\() -> ...) thunk is required, due to laziness :) -- ryan On Tue, May 19, 2009 at 4:25 PM, michael rice <nowgate(a)yahoo.com> wrote: > Hi Ryan, > > I'm afraid you've lost me. Maybe if you showed how this would be used in ML > I would get the picture. > > Michael > > --- On Tue, 5/19/09, Ryan Ingram <ryani.spam(a)gmail.com> wrote: > > From: Ryan Ingram <ryani.spam(a)gmail.com> > Subject: Re: [Haskell-cafe] showing a user defined type > To: "michael rice" <nowgate(a)yahoo.com> > Cc: "Brandon S. Allbery KF8NH" <allbery(a)ece.cmu.edu>, > haskell-cafe(a)haskell.org > Date: Tuesday, May 19, 2009, 2:40 PM > > On Tue, May 19, 2009 at 7:07 AM, michael rice <nowgate(a)yahoo.com> wrote: >> A little further along in "The Little MLer" the ints function is replaced >> by >> other functions like primes and fibs, which also return Links: >> >> fun primes(n) >> = if is_prime(n+1) >> then Link(n+1,primes) >> else primes(n+1) >> >> fun fibs(n)(m) >> = Link(n+m,fibs(m)) >> >> which are passed to chain_item: >> >> fun chain_item(n,Link(i,f)) >> = if eq_int(n,1) >> then i >> else chain_item(n-1,f(i)) >> >> which can be called to request the nth (12th) prime number beginning at 1. >> >> - chain_item(12,primes(1)); >> GC #0.0.0.1.3.61: (1 ms) >> val it = 37 : int >> - >> >> So I guess the answer to your question about whether the function is ever >> called with a different value may be, yes. > > Actually, it's not calling it with another value; notice that > chain_item calls f(i), with i coming directly from the chain. > Consider this alternate definition: > (I'm not sure the syntax is exactly right, but you get the idea) > > datatype chain = > Link of (int * ( unit -> chain )) > > fun intsFrom(n) = fun unit => (n, intsFrom (n+1)) > fun ints(n) = intsFrom n () > > Now you *can't* call the function embedded in the link with another value. > > fun chain_item(n,Link(i,f)) > = if eq_int(n,1) > then i > else chain_item(n-1,f unit) > > And this type for "chain" is almost the same as [Int] in Haskell, due > to laziness. > > -- ryan > >

2 1

Free theorems for dependent types?
by Eugene Kirpichov 20 May '09

20 May '09

Hello, Is there any research on applying free theorems / parametricity to type systems more complex than System F; namely, Fomega, or calculus of constructions and alike? This seems very promising to me for the following reason: Take the free theorem for 'sort::(a->a->Bool)->[a]->[a]'. The theorem could possibly be a lot more powerful if there were a way to encode in the type of 'sort' that it accepts a reflexive transitive antisymmetric predicate, but the only way to express that is with dependent types. Looks like the only thing one needs to add to System F is the relational translation rule for a dependent product; but I haven't tried doing it myself. -- Eugene Kirpichov Web IR developer, market.yandex.ru

7 11

Problem with haddock importing definition
by Maurício 20 May '09

20 May '09

Hi, I have a situation like this: module A imports R (a newtype declaration) from module B, and lists it in its (module A) export list. Documentation for R is included by haddock in documentation for module A, as I want. However, if my package exposes only module A, documentation for R desapears. So: if my .cabal file lists A and B in 'exposed-modules', documentation for R is included in A documentation. If I remove B from 'exposed-modules', R documentation in A desapears. Do you know what should I do? Thanks, Maurício

3 5

HaL4: Haskell-Treffen in Halle/Saale, 12. Juni 2009 - Programm und Anmeldung
by unknown＠example.com 20 May '09

20 May '09

Kindly excuse the German noise, please ... Liebe Haskell-Freunde! Das Programm fuer unser Haskell-Treffen steht jetzt so gut wie fest und man kann sich online anmelden. --------------------------------------------- HaL4 : Haskell - Tutorial + Workshop + Party am Freitag, dem 12. Juni 2009, in Halle/Saale --------------------------------------------- Das traditionsreiche HaL-Treffen bietet eine gute Mischung von Haskell-bezogenen Themen aus Forschung, Anwendung und Lehre mit vielen Möglichkeiten zu Diskussion und Unterhaltung bei der anschließenden Party. Der Workshop wird in diesem Jahr ergänzt durch Tutorien für Haskell-Ein- und Umsteiger. Diesmal findet das Treffen in Halle/Saale im Institut für Informatik der Martin-Luther-Universität Halle-Wittenberg statt. Wir bieten: 10 Uhr: Entwurfsmuster vom Kopf auf die Fuesse gestellt: data, fold und laziness statt Kompositum, Visitor, Iterator. Johannes Waldmann, HTWK Leipzig. 11 Uhr: CAL/openquark: (openquark.org) Haskell + Java => CAL, eine praktische Einfuehrung (Eclipse als CAL-IDE, Excel lesen, typsicheres SQL = LINQ fuer Java?) Alf Richter, iba Consulting, Leipzig 12 Uhr: Wie man das Semikolon ueberlaedt: Code-Strukturierung und -Wiederverwendung durch Monaden 15 Uhr: Hayoo! Haskell API Search Timo Huebel, FH Wedel 16 Uhr: Haskell als reine Spezifikationssprache Baltasar Trancon y Widemann, Universit Bayreuth 17 Uhr: Funktional-logische Programmierung mit Curry Jan Christiansen, Universitaet Kiel 19 - 22 Uhr: Grillparty Wir freuen uns auf rege Teilnahme sowie spannende Vorträge mit heißen Diskussionen und bitten um Anmeldung bis zum 31. Mai. Weitere Informationen auf http://www.iba-cg.de/hal4.html Beste Gruesse Henning Thielemann

1 0

Re: [Haskell-cafe] How i use GHC.Word.Word8 wit Int ?
by spoon＠killersmurf.com 20 May '09

20 May '09

While just writing 33 instead of length [1..33] saves an awful lot of bother, the function you'd probably want in similar circumstances is `fromIntegral` See the Prelude. Also, you can use Data.ByteString.head instead of unpack and then Data.List.head rollDice :: Word8 -> IO Word8 rollDice n = do bracket (openFile "/dev/random" ReadMode) hClose (\hd -> do v <- fmap B.head $ B.hGet hd 1 return $ (v `mod` n) + 1)

1 0