- Haskell-Cafe - Haskell.org

Rank 2 polymorphism in pattern matching?
by C Rodrigues 09 Apr '06

09 Apr '06

This counterintuitive typechecking result came up when I wrote a wrapper around runST. Is there some limitation of HM with respect to type checking pattern matching? data X a b = X (a -> a) run :: forall a. (forall b. X a b) -> a -> a -- This definition doesn't pass the typechecker run (X f) = f -- But this definition works run x = (\(X f) -> f) x

3 2

Positive integers
by Daniel McAllansmith 08 Apr '06

08 Apr '06

Unless I've missed it, there is no typeclass for positive integers in GHC. Is there any particular reason it doesn't exist? Also, it seems Word would be a far better type in the likes of (!!), length, etc. Is it just tradition that resulted in the use of Int? Daniel

16 30

Re: [Haskell] reading binary files
by Dmitry V'yal 07 Apr '06

07 Apr '06

Hello, Bulat I'm currently working on some kind of program for analysing FAT partitions. Don't ask why did I chose to implement it in Haskell :) Just for fun. My program needs to read scattered chunks of binary data from a huge file and to do a good amount of deserialisation. I implemented basic functionality using Handles and Ptr's and now I'm starting to regret for it. I have some pieces of code like: type PtrAdvancer a b = StateT (Ptr a) IO b peek_one :: Storable b => PtrAdvancer a b peek_one = do p <- get res <- lift $ peek $ castPtr p put $ plusPtr p $ sizeOf res return res peek_many :: Storable b => Int -> PtrAdvancer a [b] peek_many 0 = return [] peek_many n = do first <- peek_one rest <- peek_many $ n-1 return $ first:rest data DirEntry = DirEntry { name :: String, attr :: Word8, crt_time_tenth :: Word8, crt_time :: Word16, crt_data :: Word16, lst_acc_data :: Word16, wrt_time :: Word16, wrt_date :: Word16, fst_cluster :: Word32, file_size :: Word32 } deriving Show instance Storable DirEntry where sizeOf _ = 32 alignment _ = 32 peek = evalStateT peek_dir_entry peek_dir_entry = do n <- peek_many 11 :: PtrAdvancer a [Word8] at <- peek_one peek_one :: PtrAdvancer a Word8 ctt <- peek_one ct <- peek_one cd <- peek_one lad <- peek_one fch <- peek_one :: PtrAdvancer a Word16 wt <- peek_one wd <- peek_one fcl <- peek_one :: PtrAdvancer a Word16 fs <- peek_one return $ DirEntry (words_to_str n) at ctt ct cd lad wt wd ((fromIntegral fch `shiftL` 16) + fromIntegral fcl) fs or: read_cluster_chain32 :: Handle -> FatAddress -> Cluster -> IO [Cluster] read_cluster_chain32 h start cluster = do allocaBytes 4 $ \p -> chain32' p cluster True where chain32' p c need_seek = do when need_seek $ hSeek h AbsoluteSeek (fromIntegral $ start + c * 4) hGetBuf h p 4 val <- peek p :: IO Word32 let val28 = val .&. 0x0fffffff case val28 of 0x0 -> return [] 0x0fffffff -> return [c] otherwise -> do rest <- if c+1 == val28 then chain32' p val28 False else chain32' p val28 True return $ c:rest It works with a mediocre speed (about 10Mb/s when extracting files), but design is ugly IMO. For example I need to write twice as much number of lines of marshalling code compared to C. For data type declaration and then for Storable instance. Is there a way to avoid it? > > with my lib, you can either read data directly from file (through > implicit 512-byte buffer) or read whole file into the automatically > allocated buffer with `readFromFile`. what is better - depends on what > you plan to do with rest of file > Now I'm going to rewrite my code to make use of io library. So my question is whether your library is well suited for such application (frequent positioning and reading small pieces of data).

3 2

EnumSet with a BSD license
by David F. Place 07 Apr '06

07 Apr '06

Hi All, Since there is some interest in my EnumSet module, I am reposting it here with a BSD license in anticipation of its rebirth as Data.Set.Enum. Cheers, David -------------------------------- David F. Place mailto:d@vidplace.com

2 2

Re: [Haskell] What's up with this Haskell runtime error message:
by Michael Goodrich 07 Apr '06

07 Apr '06

Thanks so much for your help. I should have made clear that I was aware that the definitions were mutually dependent. What I was hoping was that Haskell could solve this for me without my having to resort to effectively finessing any sequencing considerations. Perhaps I am really asking it to do too much. This I thought might be reasonable since one is supposed to be achieving a sequence-less style of programming. But this would seem to be a counter example where I will be essentially forced to implement a sequential processing semantic in a language environment which ostensibly would deny me such (for my own good I understand). Thoughts? On 4/6/06, Garrett Mitchener <garrett.mitchener(a)gmail.com> wrote: > > I came up with a system of coloring -- you'll have to view this message as > html to see it. You start with the input parameters -- those are green. > Anything defined in terms of green is blue. Anything defined in terms of > green & blue is purple. Anything defined in terms of green, blue, and > purple is orange, etc. Then you can see the problem. So in foo, everything > checks out, you get to orange and there's just a couple of expressions left > and you can see that there's no loop. > > > ----------------------------------------------------------------------------------------------------------- > > > > > > foo (step,r0,mu0) = bar ( > > step,r1,r0,mu1,mu0) > > where > > r1 = r0- > > step*rd > > mu1 = mu0-step*mud > > > > rd = c*c*mu0 > > mud > > = c*c/r0 - (foobar_r z)/c > > > > c = baz(z) > > z = 6.378388e6-r0 > > > > baz z | z<125 = -0.25*z+1537.5 > > > > | otherwise = 0.0169*z+1504.1 > > > > foobar_r z | z<125 = 0.25 > > > > | otherwise = -0.0169 > > > > > But when you try coloring bar, you get this far and then we're stuck. The > problem is clear: r depends on rdc, which depends on rd0, which depends on > c0, which depends on z0, which depends on r. So your definition for r > includes a loop. > > bar > > (step,r2,r1,mu2,mu1) = (r,z0) : bar (step,r1,r,mu1,m) > > where > > r = r2 > > +2*step*rdc > > m = mu2+2*step*mudc > > rdc = ( > > rd2+rd1+rd0)/6 > > mudc = (mud2+mud1+mud0)/6 > > > > > > rd2 = c2*c2*mu2 > > mud2 > > = c2*c2/r2 - (foobar_r z2)/c2 > > > > > > rd1 = c1*c1*mu1 > > mud1 = > > c1*c1/r1 - (foobar_r z1)/c1 > > > > rd0 = c0*c0*m > > mud0 = c0*c0/r - (foobar_r z0)/c0 > > > > > > c2 = baz(z2) > > > > c1 = baz( > > z1) > > c0 = baz(z0) > > > > z2 = 6.378388e6-r2 > > z1 = 6.378388e6 > > -r1 > > z0 = 6.378388e6-r > > > > main :: IO () > > main = do > > print $ take 100 (foo (0.1, 6.378388e6,0)) > > > > > > > > > > > > >

4 4

Re: [Haskell] What's up with this Haskell runtime error message:
by Michael Goodrich 06 Apr '06

06 Apr '06

Looks like my calulation involves a self referential set of definitions. Is Haskell not able to deal with a self referential set of definitions? I was frankly hoing it would since otherwise there is then the specter of sequence, i.e. that I have to finesse the order in which things are calculated so as to avoid it. Thoughts? cheers, -Mike

5 8

"show" for functional types
by Greg Buchholz 06 Apr '06

06 Apr '06

In section 5 of _Fun with Phantom Types_, Hinze states... "Let us move on to one of the miracles of theoretical computer science. In Haskell, one cannot show values of functional types. For reasons of computability, there is no systematic way of showing functions and any ad-hoc approach would destroy referential transparency (except if show were a constant function). For instance, if show yielded the text of a function definition, we could distinguish, say, quick sort from merge sort. Substituting one for the other could then possibly change the meaning of a program." ...I guess I'm not understanding what that means. Would there be some sort of contradiction that arises when trying to evaluate "show (show)" or somesuch? Can anyone point me in the direction of information that tries to explain why this is? I'm at a loss as to what search terms to use. Thanks, Greg Buchholz

11 31

Re: [Haskell] reading binary files
by Benjamin Franksen 06 Apr '06

06 Apr '06

[questions such as this one should go to cafe] On Wednesday 05 April 2006 20:41, minh thu wrote: > 1/ i want to read some binary file (e.g. targa file format : *.tga). > > -- first way : via IOUArray > showInfoHeader1 handle = do > a <- newArray_ (1,8) :: IO (IOUArray Int Word8) > hGetArray handle a 8 > idLength <- readArray a 1 -- or getElems... > putStrLn ("id length : " ++ show idLength) > return () > > -- second way : via c-like array > showInfoHeader2 handle = do > b <- mallocArray 8 :: IO (Ptr Word8) > hGetBuf handle b 8 > [idLength] <- peekArray 1 b -- or peakArray 8 b The index should be 0 if you want to read the first byte. Also, if you are only interested in the first byte, you could simply idLength <- peek b or if it is not the first byte, then idLength <- peekByteOff b i However, it is better to use arrays, than pointers. > putStrLn ("id length : " ++ show idLength) > free b > return () > > so, briefly, i have to read some content into some kind of buffer > (IOUArray Int Word8 or Ptr Word8), then get one (or more) elements > from the buffor into a standard haskell variable (is it the correct > word ?) (or list). > > in the second case, i also have to free the buffer. Or use alloca or allocaBytes, which are both a lot faster than malloc and free. > in some case, when the data is more than one Word8 long, i have to > 'reconstruct' it, i.e.: > > [x1,x2] <- getElems a This will give you a run-time error, because you array is 8 elements long, not 2. You can do x1:x2:_ <- ... or better still x1 <- readArray b 1 x2 <- readArray b 2 Still better: Use one of the available binary serialisation libraries. They are already tuned for efficiency and give you a much nicer high-level API. > let x = fromIntegral x1 + fromIntegral x2 * 256 :: Int > > is it the correct way to read binary files ? Depends on the byte order that is used in your file format. If it is big-endian then correct, else not correct. (I hope I did get this right; I always tend to confuse big- and little-endian.) > 2/ haskell is (i heard that once ... :-) a high level language, so it > has (must have) good support for abstraction... Sure. See abve mentioned libraries. > but in 1/, i have to choose between different kind of array > representation (and i dont know which one is better) and it seems to > me that the resulting code (compiled) would have to be the same. I strongly recommend using some Array type (IOU or whatever). Ptr is really just a raw pointer into memory: no protection from out-of-bounds access, etc. much like in C. Ptr has been invented for interfacing with C routines, not for regular Haskell programming. HTH, Ben

1 0

Re: [Haskell] What's up with this Haskell runtime error message:
by Jon Fairbairn 06 Apr '06

06 Apr '06

On 2006-04-05 at 14:03EDT "Michael Goodrich" wrote: > BTW, I can't seem to locate 'haskell-cafe'. http://www.haskell.org/mailman/listinfo/haskell-cafe > The message responding to my sign-up said nothing about > haskell-cafe. Perhaps it should. It's so long since I signed up to haskell that I've forgotten what the sign-up message says. > Also, in my infinte-looping application, I am wrapping the > calculation in a 'take 1000' function - shouldn't this > guarantee termination? Not on its own loop = loop:: Char l = [1,2,3,loop,5,6] putStr $ show $ take 4 l will print 1 2 and 3 and then loop when trying to find the value for the fourth. -- Jón Fairbairn Jon.Fairbairn at cl.cam.ac.uk

1 0

Re: [Haskell] What's up with this Haskell runtime error message:
by Jon Fairbairn 06 Apr '06

06 Apr '06

On 2006-04-05 at 12:35EDT "Michael Goodrich" wrote: > Greetings All: > > GHC gives: Fail: <<loop>> > > Hugs gives: [(ERROR - C stack overflow Nowt's up wi' ' runtime error message. GHC's perfectly lucid. It says your programme went into an infinite loop. This sort of thing belongs on haskell-cafe, by the way. I've moved it there. Jón -- Jón Fairbairn Jon.Fairbairn at cl.cam.ac.uk

1 0