- Haskell-Cafe - Haskell.org

multMM :: Matrix -> Matrix -> Matrix --multiplies two matrices question (Homework)
by 조광래 05 Feb '10

05 Feb '10

hi i was trying to solve it but All i got is type Matrix=[[Double]] multMM :: Matrix -> Matrix -> Matrix --multiplies two matrices multMM m t = [[sum (zipWith (*) (head m)(a)) ] ]where a = [head a | a<- t] Main> multMM [[2,1,-6],[1,-3,2]] [[1,0,-3],[0,4,20],[-2,1,1]] [[14.0]] from this i could get only the first multiplication 14 that is by 2*1 + 1*0 + -6*-2 = 14 how can i make this go throw all rows and colums to get multiple of matrixs? Thank you~

3 2

Dutch HUG: meeting Monday 8th in Utrecht
by Tom Lokhorst 05 Feb '10

05 Feb '10

I'd like to invite functional programmers in The Netherlands to the Dutch Haskell User Group [1, 2] meeting next Monday at 19:00. Two talks are scheduled: - Sebastiaan Visser and Tom Lokhorst will give a talk entitled "AwesomePrelude, Liberating Haskell from data types!" - Martijn van Steenbergen will talk about serializing monadic computations. In particular, he will describe a monadic EDSL to describe compass-and-straightedge constructions and how to serialize and deserialize such values. The meeting will be in the Booth Hall [3] of the Utrecht University Library. There's free car parking [4] at the library, and it's easily accessible by bike and bus [5]. After the talks we will move to The Basket [6] for drinks. See you next Monday! - Tom Lokhorst [1]: http://www.haskell.org/haskellwiki/Dutch_HUG [2]: http://groups.google.com/group/dutch-hug [3]: http://www.uu.nl/EN/library/contact/university_library/zaalverhuur/Pages/de… [4]: http://www.uu.nl/EN/library/contact/university_library/Parkeren/Pages/defau… [5]: http://www.uu.nl/EN/library/contact/university_library/plattegrondenrou/Pag… [6]: http://utrecht.thebasket.nl/

1 0

safe lazy IO or Iteratee?
by David Leimbach 05 Feb '10

05 Feb '10

Hi everyone, This is not an attempt to start a flame war. I'm just trying to get a good feel for the advantages and disadvantages of the newer safe lazy io lib available on Hackage vs using Iteratee. It does appear to me that using something like Itereatee gives a bit of room to really tweak the low level enumerator/iteratee relationship, and, if you asked my old boss, I'm just a big fan of folds too, I use them a lot in my Erlang :-), so Iteratee really does appeal to me on many levels. Yet at the same time, I'm quite enamored with the beauty of "interact" and functions of that sort. I realize mixing the effects of the lazy IO and pure code may not be the clearest way to write code for everyone, but there is something about being able to get linewise data as interact (unlines . fmap someLineWiseFunction . lines) that is just kind of cool. Dave

4 5

Sparks created, but not used (par/pseq, ST monad)
by Michael Lesniak 05 Feb '10

05 Feb '10

Hello haskell-cafe, I currently have a problem with running par/pseq in the ST monad. The function testST is the minimal counterexample that works -- or, to be more clear, does not work as expected for me. As a remark, the tasks/function calls in my "real application" are much more computational expensive, but the code is too long to post here. > -- File ST.lhs > module Main where > import Control.Monad.ST > import Control.Parallel > main = testST > > testST :: IO () > testST = do > putStrLn "Starting" > (runST $ f 10) `pseq` putStrLn "Stopping" > where > f :: forall s. Int -> ST s () > f n = do > p $ "\nTask:" ++ show n > if n < 0 > then return () > else do > (n1,n2) <- return (n-1,n-2) > q n1 > q n2 > a <- f n1 > b <- f n2 > (a `par` b) `pseq` return a > > -- Some helper functions > p x = unsafeIOToST (putStrLn x) > q x = unsafeIOToST (print x) As far as I understand, compiling with ghc --make -O2 -threaded ST.lhs -o st -XRankNTypes and running with ./st +RTS -N -s should create sparks that could be run in parallel. The problem I have now, is that sparks are created but not converted, according to -s output: ... a lot of (uninteresting) stuff SPARKS: 232 (0 converted, 0 pruned) ... I have not found any information on this type of behaviour on the net and would be glad if someone could give me points or hints what's happening and how I can improve this. Cheers, Michael -- Dipl.-Inf. Michael C. Lesniak University of Kassel Programming Languages / Methodologies Research Group Department of Computer Science and Electrical Engineering Wilhelmshöher Allee 73 34121 Kassel Phone: +49-(0)561-804-6269

2 2

Re: [Haskell-cafe] safe lazy IO or Iteratee?
by John Lato 05 Feb '10

05 Feb '10

Hello, > From: David Leimbach <leimy2k(a)gmail.com> > > Hi everyone, > > Yet at the same time, I'm quite enamored with the beauty of "interact" and > functions of that sort. I realize mixing the effects of the lazy IO and > pure code may not be the clearest way to write code for everyone, but there > is something about being able to get linewise data as > > interact (unlines . fmap someLineWiseFunction . lines) > > that is just kind of cool. I think so too. I really like the "interact" style of code; I find it supremely elegant. However I also find it insufficient for many interesting cases. One general problem is the difficulty of embedding monadic code into interact functions. Usually "interact" requires a pure function. Although in many cases I think it would be possible to have interactM :: (String -> IO String) -> IO () in practice these functions don't usually exist, perhaps because they can have some surprising behavior. In my opinion IO is a weakness of Haskell, and many Haskell users either subconciously or actively seek out alternative approaches. I offer as evidence the frequency with which beginners ask the cafe about "handle closed before data could be read" errors, and also the proliferation of IO libraries. I know which I approach I think represents the best way forward, but I would be surprised if there was a community consensus at this point. In any case, I'm glad there are a multitude of options and each probably has a place and purpose. Cheers, John Lato

1 0

setNonBlockingFD?
by Magnus Therning 04 Feb '10

04 Feb '10

network-fancy fails to build because "Not in scope: 'setNonBlockingFD'". Any pointers to what should be used in 6.12? /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus＠therning．org Jabber: magnus＠therning．org http://therning.org/magnus identi.ca|twitter: magthe

3 3

ANN: progression-0.1
by Neil Brown 04 Feb '10

04 Feb '10

Hi all, I've just uploaded the first release of Progression to Hackage. Progression is a small library that pulls together several other libraries and utilities (particularly Criterion) to support the optimisation of Haskell programs. To use it, you wrap up your benchmarks in a program that passes them to Progression. When you run this program, Progression records the benchmarks, and offers to draw you a graph comparing these latest times to a selection (specified by you) of previously recorded times. What you get is a graph that allows you to see if your changes have made enough difference over your benchmarks for you to keep the change (or whether it has made most of them worse, and you need to roll back!). Progression doesn't include any benchmarking logic; it delegates all that to the Criterion library, and plots the resulting mean (with confidence intervals). More details and an example graph are available in a blog post: http://chplib.wordpress.com/2010/02/04/progression-supporting-optimisation-… Feedback is welcome, either here or in the comments on the blog post. Thanks, Neil.

1 0

Translation of Haskell type classes
by Enrique Martín 04 Feb '10

04 Feb '10

Hello all, few days ago I made some experiments with Haskell type classes. I wrote a small Haskell program for searching in sorted lists, defining my own type classes for equality (MyEq) and order (MyOrd) so that they only have one member function: -------------------------------------------------------- class MyEq a where eq :: a -> a -> Bool class MyEq a => MyOrd a where less :: a -> a -> Bool data Nat = Z | S Nat instance MyEq Nat where eq Z Z = True eq Z (S x) = False eq (S x) Z = False eq (S x) (S y) = eq x y instance MyOrd Nat where less Z Z = False less Z (S x) = True less (S x ) Z = False less (S x) (S y) = less x y search :: MyOrd a => a -> [a] -> Bool search x [] = False search x (y:ys) = (eq x y) || (less y x && search x ys) -------------------------------------------------------- I also wrote the translation of this program using the classical approach of dictionaries that appears in "How to make ad-hoc polymorphism less ad hoc", Wadler & Blott 1989 or "Type Classes in Haskell", Cordelia V. Hall et. al. 1996. -------------------------------------------------------- -- From the definition of type class MyEq data DictMyEq a = DictMyEq (a -> a -> Bool) eq :: DictMyEq a -> (a -> a -> Bool) eq (DictMyEq x) = x -- From the definition of type class MyOrd data DictMyOrd a = DictMyOrd (DictMyEq a) (a -> a -> Bool) getMyEqFromMyOrd :: DictMyOrd a -> DictMyEq a getMyEqFromMyOrd (DictMyOrd x y) = x less :: DictMyOrd a -> (a -> a -> Bool) less (DictMyOrd x y) = y data Nat = Z | S Nat -- From the instance MyEq Nat eqNat :: Nat -> Nat -> Bool eqNat Z Z = True eqNat Z (S x) = False eqNat (S x) Z = False eqNat (S x) (S y) = eqNat x y dictMyEqNat :: DictMyEq Nat dictMyEqNat = DictMyEq eqNat -- From the instance MyOrd Nat lessNat :: Nat -> Nat -> Bool lessNat Z Z = False lessNat Z (S x) = True lessNat (S x ) Z = False lessNat (S x) (S y) = lessNat x y dictMyOrdNat :: DictMyOrd Nat dictMyOrdNat = DictMyOrd dictMyEqNat lessNat search :: DictMyOrd a -> a -> [a] -> Bool search _ x [] = False search dict x (y:ys) = (eq (getMyEqFromMyOrd dict) x y) || (less dict y x && search dict x ys) -------------------------------------------------------- I made some tests in GHC 6.8.2 and I noticed that the original program with type classes runs pretty faster than the translated program. For example, reducing the expression search (S Z) (replicate 1000000 Z) needs 2.07 seconds in the original program. However the translated expression search dictMyOrdNat (S Z) (replicate 1000000 Z) needs 3.10 seconds in the translated program, which is one more second. Surprised with the results, I repeated the test this time in Hugs Sept. 2006. I noticed that the difference was not so big: search (S Z) (replicate 100000 Z) --> (2100051 reductions, 2798068 cells, 2 garbage collections) search dictMyOrdNat (S Z) (replicate 100000 Z) --> (2200051 reductions, 2898067 cells, 3 garbage collections) My first idea was that type classes were implemented using the approach of dictionaries, but the test showed me that it is not true (mainly in GHC). Then I discovered the paper "Implementing Haskell overloading", Augustsson 1993, when he describes some ways to improve the speed of Haskell overloading. So my questions are: 1) is the enhancement obtained only using the optimizations of Augustsson's paper? 2) Could anyone tell me where I can find the translation of type classes that GHC and Hugs use? Thank you very much, Enrique M.

3 2

Nested Types stack size ...
by Günther Schmidt 04 Feb '10

04 Feb '10

Hi, I'm using deeply nested types in my app and exceed some stack-size in ghci. I can't remember the runtime option I have to pass to ghci anymore, it's been about a year since I last pursued this approach. Is it also possible to set this stack-size via pragma in the source code? Günther

4 6

functional references and HList?
by Günther Schmidt 04 Feb '10

04 Feb '10

Hi all, I wonder if there is some a "field of use" overlap between HList and functional references aka accessors. Do both tackle the same problem? Günther

3 3