July 2008 - Haskell-Cafe

QuickCheck: outdated manual
by Roman Cheplyaka 09 Jul '08

09 Jul '08

Online QC manual[1] says[2] that 'vector' takes number of elements and generator, while in QuickCheck-1.1.0.0 it takes only number and generates vector of arbitrary's. Please fix that. By the way, I find the old version as useful as the new one. Although both are trivially implemented, I don't see any reason of why one is included and the other is not. Does anyone? 1. http://www.cs.chalmers.se/~rjmh/QuickCheck/manual.html 2. http://www.cs.chalmers.se/~rjmh/QuickCheck/manual_body.html#17 -- Roman I. Cheplyaka :: http://ro-che.info/ ...being in love is totally punk rock...

1 0

What is a rigid type variable?
by Xiao-Yong Jin 08 Jul '08

08 Jul '08

Hi all, I'm writing a short function as follows, but I'm not able to find a suitable type signature for `go'. It uses Numeric.LinearAlgebra from hmatrix. -- | Map each element in a vector to vectors and thus form a matrix -- | row by row mapVecToMat :: (Element a, Element b) => (a -> Vector b) -> Vector a -> Matrix b mapVecToMat f v = fromRows $ go (d - 1) [] where d = dim v go :: Element b => Int -> [Vector b] -> [Vector b] go 0 vs = f (v @> 0) : vs go !j !vs = go (j - 1) (f (v @> j) : vs) If I give the type signature to go as this, I got the following error Couldn't match expected type `b1' against inferred type `b' `b1' is a rigid type variable bound by the type signature for `go' at test.hs:36:20 `b' is a rigid type variable bound by the type signature for `mapVecToMat' at test.hs:31:35 Expected type: Vector b1 Inferred type: Vector b In the first argument of `(:)', namely `f (v @> 0)' In the expression: f (v @> 0) : vs So what is this rigid type variable all about and what is correct type of the function `go'? Thanks in advance, X-Y -- c/* __o/* <\ * (__ */\ <

5 7

more database issues
by Galchin, Vasili 08 Jul '08

08 Jul '08

vigalchin@ubuntu:~/Desktop/hsql-1.7$ runhaskell Setup.lhs clean cleaning... vigalchin@ubuntu:~/Desktop/hsql-1.7$ runhaskell Setup.lhs configure --user --prefix=$HOME Configuring hsql-1.7... Warning: No license-file field. vigalchin@ubuntu:~/Desktop/hsql-1.7$ runhaskell Setup.lhs build Preprocessing library hsql-1.7... Building hsql-1.7... Database/HSQL.hsc:66:7: Could not find module `System.Time': it is a member of package old-time-1.0.0.0, which is hidden vigalchin@ubuntu:~/Desktop/hsql-1.7$ I have a global ghc installation plus a local one off my user directory. In any case, when I do "ghc-pkg list" .... old-time-1.0.0.0 is not hidden. ???? Bottom line is how do I install DB libraries with least pain?? Regards, Vasili

3 3

data Color3 a = Color3 !a !a !a
by Daryoush Mehrtash 08 Jul '08

08 Jul '08

Can some one explain what the !a does in this: data Color3<http://cvs.haskell.org/Hugs/pages/libraries/OpenGL/Graphics-Rendering-OpenG…>a = Color3<http://cvs.haskell.org/Hugs/pages/libraries/OpenGL/Graphics-Rendering-OpenG…>!a !a !a http://cvs.haskell.org/Hugs/pages/libraries/OpenGL/Graphics-Rendering-OpenG… Thanks, Daryoush

4 3

Swapping Monads
by Dominic Steinitz 08 Jul '08

08 Jul '08

I have a solution so this is for interest only. It is not normally the case that two monads compose to give another monad. Monad transformers capture when this is possible. However, when there is a "swap" function satisfying some commutative diagrams then it can be proved that the monads compose to produce a monad. Is there such a swap function in a library? I had a look in the comprehensive category-extra package but couldn't find anything. Here's two possible implementations. Big caveat: I haven't proved that these satisfy the commutative diagrams but I am confident that they will. Option 1 define swap :: (Functor m, Monad m) => Either String (m a) -> m (Either String a) swap (Left s) = return (Left s) swap (Right x) = fmap Right x Option 2 use Traversable (EvilTerran's suggestion) instance F.Foldable (Either String) where foldMap f (Left s) = mempty foldMap f (Right x) = f x instance T.Traversable (Either String) where traverse f (Left s) = pure (Left s) traverse f (Right x) = Right <$> f x and now you can use T.sequence to swap the monads around. For further information see Composing Monads by Mark Jones and Luc Duponcheel and Toposes, Triples and Theories by Barr & Wells (Section 9.2). Dominic.

2 1

extensible data types in Haskell?
by David Walker 08 Jul '08

08 Jul '08

Hi all, SML conveniently contains the type "exn" which is an instance of an "extensible data type". In other words, unlike normal data types that are "closed" (can't admit new constructors once defined), SML's exn type is "open," allowing programmers to keep adding new alternatives as often as they choose. Like normal datatypes, the elimination form for an extensible data type is a case statement (or match function). Friends have told me that Haskell doesn't have extensible data types. However, it seems fairly straightforward to code them up using type classes....though the solution I'm thinking of has a little bit of boilerplate I'd like to scrap (you have to define a new type declaration *and* an instance of a type class with a "match" method) and matching occurs through a string comparison (which can lead to silly programmer errors if there is accidentally a typo in the string). Anyway, it's possible with some thought I could come up with a better solution, but before worrying about it, I figured I'd ask if anybody else already has a package that does this. It seems like a pretty natural feature to want to have. Thanks in advance, Dave

4 4

Hoogle often updates ?
by L.Guo 08 Jul '08

08 Jul '08

Hi Haskellers: I have just been asked for usage of timer in haskell. Which I did not remember clearly. So I ask the search engine. In Hoogle: timer In Google: haskell timer After I tried these, I wonder, when and how often the hoogle update its database? And, could hoogle search range cover the hackages? I like hoogle engine. Bcuz it is a very usful tool which helps me learn haskell. Wish it better. Regards -------------- L.Guo 2008-07-08

2 1

Avoiding lazy evaluation in an ErrorT computation
by Tim Bauer 07 Jul '08

07 Jul '08

The file below models a problem I have been trying to figure out. This file simplifies my original code, while still illustrating the problem. > import Prelude hiding (catch) > import Control.Monad.Reader > import Control.Monad.Error > import Control.Exception > import System.IO(readFile) > import Data.Either(either) Our monad transformer is an ErrorT which wraps the IO monad. ErrorT allows us to use throwError, but we won't use it in this example. > type T a = ErrorT String IO a The following runs a (T a) in the context of the IO monad. We wrap runErrorT in try so as to catch things like division by zero and what not. > doTinIO :: T a -> IO (Either String a) > doTinIO ta = do > exesa <- try (runErrorT ta) -- IO (Either Exception (Either String a)) > return $ case exesa of > Left x -> Left ("EX: "++(show x)) > Right esa -> esa > > boom = 1 `div` 0 > b1 = return boom :: T Int > bad = doTinIO b1 The above, bad, results in: Right *** Exception: divide by zero My hope was to get Left "EX: divide by zero" I cannot understand why the `try' does not get a chance at the erroneous calculation. That is, I want the try to catch the runtime exception. Indeed, if the IO computation is strictly computed, I get the proper result. > g1 = boom `seq` (return boom :: T Int) > good = doTinIO g1 Stuff that raises exceptions in IO actions does not work either. > g2 = doTinIO (return boom) Results in: ``Right *** Exception: divide by zero'' However, other actions that do raise errors work correctly. It appears the value of the computation must be used as the next two examples show. > g3 = doTinIO (liftIO (readFile "nonexistent")) > g4 = doTinIO (liftIO (print boom)) My problem is that I control `doTinIO', but someone else provides the computation (T a). I cannot force callers to strictly evaluate their computations. I've tried three other variants (given below) that are all nearly equivalent. > handler :: Exception -> IO (Either String a) > handler = return . Left . ("EX: "++) . show > > doTinIO2 :: T a -> IO (Either String a) > doTinIO2 ta = catch (runErrorT ta >>= evaluate) handler > > doTinIO3 :: T a -> IO (Either String a) > doTinIO3 ta = do > esa <- catch (runErrorT ta) handler > case esa of > Right a -> catch (evaluate (return a)) handler > l -> return l > > doTinIO4 :: T a -> IO (Either String a) > doTinIO4 ta = catch (runErrorT ta) handler *Main> doTinIO2 b1 Right *** Exception: divide by zero *Main> doTinIO3 b1 Right *** Exception: divide by zero *Main> doTinIO4 b1 Right *** Exception: divide by zero Any suggestions? Thanks all.

4 3

A Monad for on-demand file generation?
by Joachim Breitner 07 Jul '08

07 Jul '08

Hi, for an application such as a image gallery generator, that works on a bunch of input files (that are assumed to be constant during one run of the program) and generates or updates a bunch of output files, I often had the problem of manually tracking what input files a certain output file depends on, to check the timestamps if it is necessary to re-create the file. I thought a while how to do this with a monad that does the bookkeeping for me. Assuming it’s called ODIO (On demand IO), I’d like a piece of code like this: do file1 <- readFileOD "someInput" file2 <- readFileOD "someOtherInput" writeFileOD "someOutput" (someComplexFunction file1 file2) only actually read "someInput" and "someOtherInput", do the calculation and write the output if these have newer time stamps than the output. The problem I stumbled over was that considering the type of >>= (>>=): Monad m => m a -> (a -> m b) -> m b means that I can not „look ahead“ what files would be written without actually reading the requested file. Of course this is not always possible, although I expect this code to be the exception: do file1 <- readFileOD "someInput" file2 <- readFileOD "someOtherInput" let filename = decideFileNamenameBasedOn file2 writeFileOD filename (someComplexFunction file1 file2) But assuming that the input does not change during one run of the program, it should be safe to use "unsafeInterleaveIO" to only open and read the input when used. Then, the readFileOD could put the timestamp of the read file in a Monad-local state and the writeFileOD could, if the output is newer then all inputs listed in the state, skip the writing and thus the unsafeInterleaveIO’ed file reads are skipped as well, if they were not required for deciding the flow of the program. One nice thing is that the implementation of (>>) knows that files read in the first action will not affect files written in the second, so in contrast to MonadState, we can forget about them, which I hope leads to quite good guesses as to what files are relevant for a certain writeFileOD operation. Also, a function cacheResultOD :: (Read a, Show a) => FilePath -> a -> ODIO a can be used to write an (expensive) intermediate result, such as the extracted exif information from a file, to disk, so that it can be used without actually re-reading the large image file. Is that a sane idea? I’m also considering to use this example for a talk about monads at the GPN¹ next weekend. Greetings, Joachim ¹ http://entropia.de/wiki/GPN7 -- Joachim "nomeata" Breitner mail: mail(a)joachim-breitner.de | ICQ# 74513189 | GPG-Key: 4743206C JID: nomeata(a)joachim-breitner.de | http://www.joachim-breitner.de/ Debian Developer: nomeata(a)debian.org

10 19

type classes
by Cotton Seed 07 Jul '08

07 Jul '08

Hi everyone, I'm working on a computational algebra program and I've run into a problem. In my program, I have types for instances of algebraic objects, e.g. ZModN for modular integers, and types for the objects themselves, e.g. ZModNTy for the ring of modular integers. Now, I want to subclass ZModNTy from something like class RingTy a b where order :: a -> Integer units :: a -> [b] where `a' represents algebraic object, and `b' the type of instances of that object. I want an instance instance RingTy ZModNTy ZModN where ... but then code that only uses order fails with errors like No instance for (RingTy ZModNTy b) arising from a use of `order' at Test2.hs:16:8-15 since there is no constraint on the second type variable. I think what I really want is class RingTy a where order :: a b -> Integer units :: a b -> [b] but this doesn't work either since ZModNTy is not parametric in its type like, say, `Polynomial a' is. Is this a common problem? Is there a standard way to handle it? Thank you for your attention, Cotton

5 7