- Haskell-Cafe - Haskell.org

Substitute for records?
by Mattias Bengtsson 10 Apr '06

10 Apr '06

Currently i'm working, together with a friend, on an abstraction (sort of) of HaskellDB for a school-project. Basically we are generating haskell-modules similar to those generated by DBDirect in HaskellDB together with some helpers for the most common queries you'd want to run. HaskellDB has its own record system (HDBRec) and a HaskellDB-query also returns such a record. The accessor-functions for these records can later be found in DatabaseName.TableName.ColumnName.column. These should be imported qualified to avoid name clashes. This is some example code: students <- School.Students.all db mapM_ printStudentId students printStudentId rec = print $ rec!School.Students.Id.column The main problem for me here is this part: rec!School.Students.Name.column where i would rather just write rec!id This isn't possible and the other way is just too messy for my taste. It simply isn't the easy and nice syntax i had hoped for when we started to develop this. Are there any other nice substitutes for HDBRec or normal haskell records that i could use that doesn't make name clashes an issue? Mattias

2 1

Understanding allocation behavior
by David F. Place 10 Apr '06

10 Apr '06

After reading Daniel Fischer's message about trying to use EnumSet in his Sudoku.hs and finding that it was slower when processing a large data set, I decided to do some profiling. I rewrote his solver to use EnumSets and profiled it. The culprit turns out to be the following function which is responsible for 22% of the allocating in the run. Is there a more efficient way to write this function? foldBits :: Bits c => (a -> Int -> a) -> a -> c -> a foldbits _ z 0 = z foldBits f z bs = foldBits' f 0 bs z foldBits' :: Bits c => (a -> Int -> a) -> Int -> c -> a -> a foldBits' f i bs z | bs == 0 = z | otherwise = z' `seq` foldBits' f i' bs' z' where z' | 1 == bs .&. 1 = f z i | otherwise = z i' = i + 1 bs' = bs `shiftR` 1 ps. I was impressed with how hairy DF's algorithm is and I am not really enough interested in Sudoku to spend the time needed to grok it. So, I decided to try an experiment to see if I could restructure it without understanding it very deeply. Step 1. comment out all the type signatures. Step 2. find the main place that I wanted to change from [Int] to (Set Int) Step 3. compile; make obvious edits; repeat until 0 errors I had it running in a few minutes. I can't imagine doing that in any other programming environment! Cheers, David -------------------------------- David F. Place mailto:d@vidplace.com

4 12

lambda evaluator in GADT
by paul＠theV.net 10 Apr '06

10 Apr '06

The introduction to GADT usually starts with a little expression evaluator. So I gave it a try, but there are some troubles. A little data type for lambda expression > data E a where > Lit :: a -> E a > App :: E (a -> b) -> E a -> E b > Lam :: Var a -> E b -> E (a -> b) > Val :: Var a -> E a > > data Var a = Var String some sample values > e1 = Lit 1 > plus = Lit (\x y -> x + y) Next, plus' demonstrate a pitfall in my data definition, i.e., the variable introduced by Lam has type forall a . a, which is is too general force a constraint on its occurrances. I wonder if there a way to make it work. > plus' = let v1 = Var "x" > v2 = Var "y" > in Lam v1 (Lam v2 (App (App plus (Val v1)) (Val v2))) evaluation > eval :: E a -> a > eval (Lit x) = x > eval (App f x) = (eval f) (eval x) > eval (Lam (Var v) e) = \x -> eval (sub v (Lit x) e) > eval (Val (Var v)) = undefined substituation > sub :: String -> E b -> E c -> E c > sub v e e1@(Lit x) = e1 > sub v e (App f x) = App (sub v e f) (sub v e x) > sub v e e'@(Lam w'@(Var w) x) = > if v == w then e' > else Lam w' (sub v e x) the above all works fine, except for the following > {-- > sub v e e'@(Val (Var w)) = > if v == w then e > else e' > --} It seems the last case requires a unification of b and c, which is simply too strong for other cases. What should I do here? Instead of substituting on term level, an alternative way to implement eval is to use an environment to map variables to its values, but that requires all expression values to have a uniform type, which is a conflict to GADT. I'm sure this could be a common issue encountered by GADT beginners, how does one get around it? One solution on top of my head is to use a sum type (or even type class) and stuff every possible value types under it, but that defeats the purpose of using GADT in the first place. Any help is greatly appreciated! Regards, Paul Liu

2 1

Chapter 4 of Hitchhikers Guide to the Haskell is out
by Dmitry Astapov 09 Apr '06

09 Apr '06

Hello, After great amount of procrastination I finally put online the next installment of my Haskell tutorial, which could be found at http://www.haskell.org/haskellwiki/Hitchhikers_Guide_to_the_Haskell Many thanks to all who commented on my efforst, spell-checked the text and urged me to go forward. As alway I'm interested in any feedback. -- Dmitry Astapov //ADEpt GPG KeyID/fprint: F5D7639D/CA36 E6C4 815D 434D 0498 2B08 7867 4860 F5D7 639D

1 0

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

08 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 06 Apr '06

06 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 06 Apr '06

06 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