December 2009 - Haskell-Cafe

powering of new types
by slemi 22 Dec '09

22 Dec '09

hey there and thanks for the replies to my earlier question, here is the next one: i have defined both the (*) and (/) operators for my new type data Matrix a = Matr {unMatr :: [[a]]} | Scalar a deriving (Show, Eq) (*) being matrix multiplication and (/) being multiplication with inverse i also defined them for scalars this allows me to use the (^^) powering operator, which works fine with non-zero exponents. however to my surprise when i try (^^ 0) the answer is (Scalar 1), and not the identity matrix as expected. does this mean that (a ^^ 0) is not defined as (a ^^ 1 * a ^^ (-1)) (or better yet (a / a)) in the prelude? if so, can i redefine it so that it gives the right answer? i am also very interested in how ghci got the answer (Scalar 1), it seems quite magical:) here are my operator definitions: instance RealFrac a => Num (Matrix a) where (Matr as) * (Matr bs) = Matr $ timesH as bs (Scalar a) * (Matr b) = Matr $ timesSH a b (Matr a) * (Scalar b) = Matr $ timesSH b a (Scalar a) * (Scalar b) = Scalar (a * b) instance RealFrac a => Fractional (Matrix a) where (Scalar a) / (Scalar b) = Scalar (a / b) (Matr a) / (Scalar b) = Matr $ map (map (/ b)) a a / b | a == b = idM a | otherwise = a * (inv b) liftMatr = (Matr .) . (. unMatr) transH = foldr (zipWith (:)) (repeat []) timesH :: RealFrac a => [[a]] -> [[a]] -> [[a]] timesH as bs = map (\p -> map (foldr1 (+) . zipWith (*) p) (transH bs)) as timesSH :: RealFrac a => a -> [[a]] -> [[a]] timesSH a = map (map (a *)) idM :: RealFrac a => Matrix a -> Matrix a idM = liftMatr idMH idMH :: RealFrac a => [[a]] -> [[a]] idMH as = let n = length as in take n . map (take n) . iterate (0 :) $ 1 :repeat 0 -- View this message in context: http://old.nabble.com/powering-of-new-types-tp26891202p26891202.html Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 3

ANNOUNCE: Haddock 2.6.0
by David Waern 22 Dec '09

22 Dec '09

-------------------------------------------- -- Haddock 2.6.0 -------------------------------------------- A new version of Haddock, the Haskell documentation tool, is out! This is the version that comes with GHC 6.12.1. It contains the main results of Isaac Dupree's Summer of Code project, which are: * Cross-package documentation (exporting something that comes from another package is handled correctly. The full documentation of that thing shows up in your documentation) * Lexing and parsing of Haddock comment markup is moved from GHC back into Haddock. This will make it easier to make changes to the markup format We have decided to drop compatibility with older GHC versions in order to speed up development. -------------------------------------------- -- Full list of changes in version 2.6.0 -------------------------------------------- * Drop support for GHC 6.10.* * Add support for GHC 6.12.1 * Cross-package documentation * Move lexing and parsing of the Haddock comment markup back to Haddock * Slightly prettier printing of instance heads * Support platforms for which GHC has no native code generator * Add a flag --print-ghc-libdir * Minor bug fixes -------------------------------------------- -- Links -------------------------------------------- Homepage: http://www.haskell.org/haddock Hackage page: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/haddock-2.6.0 Bugtracker and wiki: http://trac.haskell.org/haddock Mailing list: haddock(a)projects.haskell.org Code repository: http://code.haskell.org/haddock -------------------------------------------- -- Contributors -------------------------------------------- The following people contributed patches to this release: Isaac Dupree Ian Lynagh Simon Peyton-Jones David Waern -------------------------------------------- -- Get Involved -------------------------------------------- We would be very happy to get more contributors. To get involved, start by grabbing the code: http://code.haskell.org/haddock Then take a look at the bug and feature tracker for things to work on: http://trac.haskell.org/haddock

1 0

How can i set the seed random number generator ?
by zaxis 22 Dec '09

22 Dec '09

In erlang, first i use the following function to set the seed: new_seed() -> {_,_,X} = erlang:now(), {H,M,S} = time(), H1 = H * X rem 32767, M1 = M * X rem 32767, S1 = S * X rem 32767, put(random_seed, {H1,M1,S1}). then use random:uniform/1 to get the random number. In haskell, i just use the following function to get the random number. It seems i donot need to set the seed of random number generator manually? rollDice :: Int -> IO Int rollDice n = randomRIO(1,n) Sincerely! ----- fac n = foldr (*) 1 [1..n] -- View this message in context: http://old.nabble.com/How-can-i-set-the-seed-random-number-generator---tp26… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 2

Parse do block problem
by joeltt 22 Dec '09

22 Dec '09

I'm trying to write my first Haskell program. The below is the first real logic block I've tried to write, unfortunately I get a "The last statement in a 'do' construct must be an expression" error when loading the method. However, the location of this problem isn't very clear. Is there a way to get more detailed parse message from Haskell, or can someone tell me where the problem is (and better "why"?). I don't think I actually need to use a "do" IO/Monad theme here, but its not clear to me either way. This isn't homework, its just for fun... do_solve_iter guess tried = do let actual = count_occurences guess if guess == actual then putStrLn "ANSWER!!" else if (find (==actual) tried) == Just actual then do putStrLn "NO ANSWER!" putStrLn tried else do putStrLn "ITER" do_solve_iter actual (actual : tried) -- View this message in context: http://old.nabble.com/Parse-do-block-problem-tp26883702p26883702.html Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 3

Pattern matching, and bugs
by András Mocsáry 21 Dec '09

21 Dec '09

Hello, I was advised respectfully to post my query here. Please, read the whole letter before you do anything, because I tried to construct the problem step by step. Also keep in mind, that the problem I query here is more general, and similar cases occur elsewhere, not just in this particular example I present below. *Intro story* ( Skip if you are in a hurry ) I'm participating in several open-source server development projects, most of them are written in C, and some of them have C++ code hidden here and there. These programs, are developed by many, and by many ways, and so, more often than not it is very hard to determine the 'real cause of bugs'. This almost always leads to 'bugfixes' which 'treat the crash'. Sometimes they are a few lines of extra checks, like IFs. Sometimes they are complex, and even surprisingly clever hacks. Thus understanding the 'code' of them is challenging, but the end result is a pile of ... hacks fixing bugs fixing hacks fixing bug, which also were put there to fix yet another bugs. + When I started to learn functional programming, I was told, that the correctness of a functional program can be proved a lot more easily, in fact in a straight mathematical way. + *My concern* is about predictable failure of sw written in Haskell. To illustrate it let's see a Haskell pattern matching example: Let's say I have defined some states my object could be in, and I did in a switch in some C-like language: > switch ( x ) { Case 0: "Unchecked" Case 1: "Checked" Case 2: "Unknown" } And in Haskell pattern matching: switch 1 = "Unchecked" switch 2 = "Checked" switch 3 = "Unknown" Let's say, these are clearly defined states of some objects. Then let's say something unexpected happens: x gets something else than 0 1 2. Now we have a problem, which is most generally fixed in these ways: C-like: > switch ( x ) { Case 0: "Unchecked" Case 1: "Checked" Case 2: "Unknown" Default: "Nothing" } Haskell like: switch 1 = "Unchecked" switch 2 = "Checked" switch 3 = "Unknown" switch x = "Nothing" These general ways really avoid this particular crash, but does something real bad to the code in my opinion. Below are some cases x can go wrong: *1. The bad data we got as 'x', could have came from an another part of our very program, which is the REAL CAUSE of the crash, but we successfully hide it.* * Which makes it harder to fix later, and thus eventually means the death of the software product. Eventually someone has to rewrite it. Which is economically bad for the company, since rewriting implies increased costs. 2. The bad data we got as 'x', could also could have come form a real word object, we have underestimated, or which changed in the meantime. 3. This 'x' could have been corrupted over a network, or by 'mingling' or by other faulty software or something. Point 1: If we allow ourself such general bugfixes, we eventually kill the ability of the project to 'evolve'. Point 2: Programmers eventually take up such 'arguably bad' habits, thus making harder to find such bugs. Thus it would be wiser to tell my people to never write Default cases, and such general pattern matching cases. * Which leads to the very reason I wrote to you: I want to propose this for Haskell prime: I would like to have a way for Haskell, not to crash, when my coders write pattern matching without the above mentioned general case. Like having the compiler auto-include those general cases for us, but when those cases got hit, then* instead of crashing*, it *should **report some error* on *stdout *or *stderr*. (It would be even nicer if it cold have been traced.) This is very much like warning suppression, just that it's crash suppression, with the need of a report message of course. *I would like to hear your opinion on this.* I also think, that there are many similar cases in haskell, where not crashing, just error reporting would be way more beneficial. In my case for server software, where network corrupted data, ( and data which has been 'tampered with' by some 'good guy' who think he's robin hood if he can 'hack' the server ) is an every day reality. Thanks for your time reading my 'storm'. Greets, Andrew

7 6

Infix instance headers
by Bas van Dijk 21 Dec '09

21 Dec '09

Hello, What's the reason that infix class declarations and infix constraints are supported but infix instance heads aren't? For example the following code from my regions package is allowed but writing the instance header infix results in a "Malformed instance header" error: class (Monad pr, Monad cr) => pr `ParentOf` cr instance Monad r => ParentOf r r instance ( Monad cr , cr `TypeCast2` RegionT resource s pcr , pr `ParentOf` pcr ) => ParentOf pr cr regards, Bas

1 0

Haskell Web News: Looking back on 2009
by Don Stewart 21 Dec '09

21 Dec '09

The Haskell Web News is a monthly summary of the hottest news about the Haskell programming language, as found in our online communities. If you want to catch up with what’s been happening in Haskell, this might be the journal for you. In this edition, we look back on the major events of 2009. http://haskellwebnews.wordpress.com/2009/12/20/the-year-in-haskell/ -- Don

2 1

no sparks?
by Jamie Morgenstern 21 Dec '09

21 Dec '09

Hello; I am writing a parallel theorem prover using Haskell, and I am trying to do several things. As a first cut, I want to try using the par construct to attempt right and left rules simultaneously, and to evaluate both branches of an and clause in parallel. My code (attached) does not seem to generate sparks, however. When I run ./proposition +RTS -N2 -sstderr I get that no sparks are created. What am I doing wrong? Also, I was wondering if something akin to a "parallel or" exists. By this, I mean I am looking for a function which, given x : a , y : a, returns either, whichever computation returns first. Can I use strategies to code up something like this? I suppose this doesn't play nicely with the idea of determinism, but thought it might be worth asking anyway. Thanks, -Jamie

8 13

Largest types in SYB
by Paul Keir 21 Dec '09

21 Dec '09

I was looking for a simple generic technique targeting and transforming the "largest" terms of a particular type. For example, with Expr and Val declared as: data Expr = Val Val | Add Expr Expr | Sub Expr Expr deriving (Show, Eq, Typeable, Data) data Val = Var String | Struct [Expr] deriving (Show, Eq, Typeable, Data) and a test Expr "e", e = Sub (Val $ Var "A") (Add (Val $ Var "X1") (Val $ Struct [Add (Val $ Var "Y1") (Val $ Var "Y2")])) I wanted to replace only the inner "Add" expression Add (Val $ Var "Y1") (Val $ Var "Y2") because its "parent" is not of the same type as itself (it's a list), using a function such as chopAdd: chopAdd (Add _ _) = Val $ Var "AddChop" chopAdd e = e But using "everywhere" from Scrap Your BoilerPlate (SYB): everywhere (mkT repAdd) e I'd get: Sub (Val (Var "A")) (Val (Var "AddChop")) while I was hoping for: Sub (Val (Var "A")) (Add (Val (Var "X1")) (Val (Struct [Val (Var "AddChop")]))) The Haskell.org SYB wiki presents "listifyWholeLists". This is relevant, though it applies queries rather than transformations. It uses a function called synthesize, which I was ultimately unable to properly reference, or apply to the problem at hand. So here is my solution: everywhereBar :: GenericQ Bool -> GenericT -> GenericT everywhereBar q f x | q x = (gmapT (everywhereBar (typeEq x) f) x) | otherwise = f (gmapT (everywhereBar (typeEq x) f) x) where typeEq p c = typeOf p == typeOf c It's like SYB's "everywhereBut", except 1. The consequence of q x being True is only to remove the application of f to the "parent"; not to stop traversal. 2. q is not constant. Instead it is the partial application of a local function, "typeEq". An application looks like: everywhereBar (const False) (mkT repAdd) e with (const False) the user is choosing the outcome of the very first "q x" in "everywhereBar". I'm enjoying using SYB, and had hoped to use only functions from the package, but couldn't find a way; and this does the job for now. I've also seen that there are many other approaches to generic programming than SYB (even for AST transformations in particular) but I wanted to understand SYB first. I'm interested to know if anyone has a more elegant SYB solution. And here's the monadic version: everywhereBarM :: Monad m => GenericQ Bool -> GenericM m -> GenericM m everywhereBarM q f x | q x = gmapM (everywhereBarM (typeEq x) f) x | otherwise = do x' <- gmapM (everywhereBarM (typeEq x) f) x f x' where typeEq p c = typeOf p == typeOf c Cheers, Paul The University of Glasgow, charity number SC004401

2 1

HList and SQL ... looking for working examples
by Günther Schmidt 21 Dec '09

21 Dec '09

Hi, I'm trying express relational algebra terms by using Oleg's HList. Table definitions and such. Are there any working examples for this? Günther

2 2