- Haskell-Cafe - Haskell.org

Is there a sample code for hdbus?
by Magicloud Magiclouds 27 Jul '09

27 Jul '09

Hi, Although I have used dbus with ruby a little, but still, I do not understand hdbus's APIs.... Is there any sample that I could learn? Thanks. -- 竹密岂妨流水过山高哪阻野云飞

1 0

Data.Binary.encode slower than show
by Grzegorz Chrupała 27 Jul '09

27 Jul '09

Hi all, I have a piece of code where I'm serializing a datastructure with the following type [(Int, (Map DType (IntMap Int)))], using Binary.encode The thing is it is very slow: actually quite a bit slower than just using show. This seems rather suspicious. Any idea what could be going on? import qualified Data.Map as Map import qualified Data.IntMap as IntMap import Data.IntMap ((!)) import Vector import Atom import Control.Monad.State import Indexing (indexBy) import Data.List (foldl') import System import System.IO import Debug.Trace import qualified Data.Binary as Binary import qualified Data.ByteString.Lazy as BS data DType = Fol | For | Sol | Sor deriving (Eq,Enum,Ord,Show,Read) instance Binary.Binary DType where get = do x <- Binary.get return (toEnum x) put x = Binary.put (fromEnum x) type Word = Int type Count = Int type WordMap = IntMap.IntMap find = IntMap.findWithDefault IntMap.empty distReps :: Map.Map (Word,Word) Count -> [(Int, (Map.Map DType (WordMap Count)))] distReps bidict = let bigrams = Map.toList bidict for = indexBy id bigrams fol = indexBy swap bigrams ws = map (fst . fst) bigrams r = flip map ws $ \w -> (w,Map.fromList [ (Fol , find w fol) , (For , find w for) , (Sol , sox for fol w ) , (Sor , sox fol for w ) ]) in trace (show $ r == r) r sox :: WordMap (WordMap Count) -> WordMap (WordMap Count) -> Word -> WordMap Count sox fox foy w = let xs = IntMap.keys (find w fox) f !z x = let xv = find x foy in xv == xv `seq` z `plus` xv in foldl' f IntMap.empty xs swap (!a,!b) = (b,a) readBigrams = fmap (map (\ [w,w',c] -> ((w,w'),read c)) . map words . lines ) getContents main = do [f] <- getArgs bigrams <- readBigrams let (bigrams',as) = flip runState empty (atomize bigrams) dr = distReps (Map.fromList bigrams') write f dr hPutStrLn stderr "Done this" write (f++".atom") as --write f d = writeFile f (show d) write f d = BS.writeFile f (Binary.encode d) atomize xs = mapM f xs where f ((w,w'),!i) = do !i_w <- toAtom w' !i_w' <- toAtom w let r = ((i_w,i_w'),i) r == r `seq` return r -- Grzegorz

2 1

TBC: Testing By Convention
by Peter Gammie 27 Jul '09

27 Jul '09

Hello, Mark and I would like to announce our test harness, which has features complementary to existing harnesses. TBC provides two main features: - It attempts to compile and run all tests, even if some do not compile or run. - Aspiring to the write-it-once principle, tests following conventions require a lot less boilerplate. It is at an embryonic stage of development, and would greatly benefit from feedback and/or patches. :-) Hackage: http://hackage.haskell.org/package/TBC git: http://github.com/peteg/TBC/ Enjoy! cheers peter -- http://peteg.org/

2 2

Is a bug?
by Linker 27 Jul '09

27 Jul '09

Hi,All! I find out that diff between GHC and Hugs: GHC: *Prelude> sqrt 3+4+9 14.732050807568877 Prelude> sqrt 16 4.0 Prelude> sqrt $3+4+9 14.732050807568877* Hugs:*Hugs> sqrt $ 3+4+9* *4.0* *Hugs> sqrt 3+4+9* *14.7320508075689* Which one is right? Thanks. -- Regards, Linker Lin linker.m.lin(a)gmail.com

2 2

ANN: Elerea version 1.x.x
by Patai Gergely 26 Jul '09

26 Jul '09

Hi all, Having taken a short break from my profiling project, I updated my little FRP library called Elerea [1] along with the runnable example programs [2]. The interface was changed into a monadic-applicative hybrid that distinguishes stateful and stateless combinators for safety reasons. Since this is a major change, this release bears a new major version number. Most importantly, the latcher was removed due to various practical issues, and it is replaced by much better behaved stateless higher-order constructs. The library is capable of handling arbitrary higher-order signals, e.g. dynamic collections of signals, as shown by the renewed breakout example (which used to cheat so far by treating the state of the brick collection as a single value). I intend to write some tutorials later, but feel free to experiment until then. Gergely [1] http://hackage.haskell.org/package/elerea [2] http://hackage.haskell.org/package/elerea-examples -- http://www.fastmail.fm - The professional email service

1 0

Recompiling Hackage to estimate the impact of a change [Was: StricterLabelledFieldSyntax]
by Johan Tibell 26 Jul '09

26 Jul '09

On Sun, Jul 26, 2009 at 3:34 AM, Ian Lynagh <igloo(a)earth.li> wrote: > Hi all, > > I've made a ticket and proposal page for making the labelled field > syntax stricter, e.g. making this illegal: > > data A = A {x :: Int} > > y :: Maybe A > y = Just A {x = 5} > > and requiring this instead: > > data A = A {x :: Int} > > y :: Maybe A > y = Just (A {x = 5}) > > http://hackage.haskell.org/trac/haskell-prime/ticket/132 > > http://hackage.haskell.org/trac/haskell-prime/wiki/StricterLabelledFieldSyn… > In general, I think it would be a good idea to provide some statistics of how many packages would break as the result of a backwards incompatible change. Without that data I find it hard to do a cost-benefit analysis. So I hereby suggest that we make a recompile of Hackage a requirement for any breaking language changes. I understand that it might not be that easy to recompile all of Hackage at the moment so we should try to come up with some step-by-step instructions on how to do it. In the future it would be nice to have a little script that does it and spits out some statistics. Cheers, Johan

4 5

ANN: haskell-src-exts-1.1.0
by Niklas Broberg 26 Jul '09

26 Jul '09

Fellow Haskelleers, I'm pleased to announce the release of haskell-src-exts-1.1.0, bringing you tuple sections, comments, and a few bug fixes. haskell-src-exts is a package for Haskell source code manipulation. In particular it defines an abstract syntax tree representation, and a parser and pretty-printer to convert between this representation and String. It handles (almost) all syntactic extensions to the Haskell 98 standard implemented by GHC, and the parsing can be parametrised on what extensions to recognise. haskell-src-exts 1.1.0: =================== * Adds rudimentary support for retaining comments while parsing a source document. The support currently comes in the following form: - The module Language.Haskell.Exts.Comments defines a datatype Comment with two constructors denoting single-line (--) and multi-line ({- -}) comments. - The Parseable class is extended with a function 'parseWithComments :: Parseable ast => ParseMode -> String -> ParseResult (ast, [Comment])' which simply returns all comments as a list alongside the AST. There are also specialised versions for the usual suspects. Example run: HSE> parseExpWithComments defaultParseMode "1 + {- comment -} 4 -- end\n" ParseOk (InfixApp (Lit (Int 1)) (QVarOp (UnQual (Symbol "+"))) (Lit (Int 4)),[Mu ltiLine (SrcLoc {srcFilename = "<unknown>.hs", srcLine = 1, srcColumn = 3}) " co mment ",SingleLine (SrcLoc {srcFilename = "<unknown>.hs", srcLine = 1, srcColumn = 19}) " end"]) This first release of comment support is as seen very rudimentary, but I'm releasing it early in the hope that people who need features tied to this will start looking at what's there and send me comments on what further support they would like to see and consider missing. * Support for TupleSections: <http://hackage.haskell.org/trac/ghc/ticket/3377> * Fixes a bug where the statements of a list comprehension were returned in the wrong order (oops!). * Fixes a bug where function definitions were printed incorrectly when using PPOffsideRule - thanks to Mathieu Boespflug for the patch. * Fixes the broken 'cabal test' - thanks to Robin Green for the entire test runner support! Cheers and Happy Haskelling, /Niklas

1 0

Pattern matching with where free variables can be used more than once
by Christopher Done 26 Jul '09

26 Jul '09

Wouldn't it be great if pattern variables could be used more than once in a pattern? Like so: foo [x,x,_,x] = "The values are the same!" foo _ = "They're not the same!" where this could be rewritten to: foo [x,y,_,z] | x == y && x == z = "The values are the same!" foo _ = "They're not the same!" It seems like a straight-forward translation and there wouldn't be a speed hit for normal patterns because it would only be triggered in compilation where the same free variable appears twice. Implications are: 1. in ``foo [x,y] = ...'', x has type a 1. in ``foo [x,x] = ...'', x has type Eq a => a Was this ever considered? Is it a bad idea for some reason I'm not aware of? On a mildly irrelevant note, I have observed newbies to the language wonder why on earth it's not already like this. Cheers

5 5

Can sub-classes inheriting instances of parent class?
by Szekeres István 25 Jul '09

25 Jul '09

Hi, I'm trying to do something like the following: class Foo a where doit :: (String -> IO ()) -> a -> IO () instance Foo Int where doit f = f . show instance Foo Char where doit f = f . (:[]) So now I have a "doit" function for Ints and Chars, that takes a function and does the IO with the given function. Now I could define function p as p :: (Foo a) => a -> IO () p = doit putStrLn so I could do main = do p 3 p 'X' in main, but I would like to compeltely hide the fact from p that it somehow belongs to the Foo class, so I would like to do something like this: class Foo a => Bar a where p2 :: a -> IO () p2 = doit putStrln but, though Foo Int and Foo Char are defined, Bar Int and Bar Char are not defined automatically, so given this class definition I will not be able to call p2 3 and p2 'X' Is there still some way to do something like this? Thanks, Istvan

1 0

Memoized game-tree evaluation
by Matthew 25 Jul '09

25 Jul '09

I'm working on defining a data type for representing game-trees for chess or other two-person board games. My plan is to memoize the evaluations of a game-state at each depth so that values don't need to be recomputed for future moves. Here's the definition I'm using so far: data GameState = GameState {color :: Color, board :: Board} data GameTree = GameTree {state :: GameState, values :: [Int], branches :: [GameTree]} genGameTree :: GameState -> GameTree genGameTree st | finalState st = GameTree st (repeat (evalState st)) [] | otherwise = GameTree st vs bs where bs = map genGameTree (nextStates st) vs = (evalState st) : map (\d -> (optimize (color st)) (map ((!!d) . values) bs)) [0..] optimize Black = minimum optimize White = maximum I'd like to rewrite the generation of "vs" to evaluate using alpha- beta cutoffs, but I'm having trouble coming up with a way to do so without losing memoization. I don't know if my failures so far are because ab-pruning is necessarily incompatible with memoization, or if I simply haven't found the right insight yet. Can anyone suggest a solution, or convince me there isn't one? Thanks in advance.

2 1