April 2007 - Haskell-Cafe

MPTC and type classes issue (polymorphic '+')
by Joel Reymont 07 Apr '07

07 Apr '07

Folks, I'm trying to save time when typing in my ASTs so I thought I would create a Plus class like this (I do hide the one from Prelude) class PlusClass a b c | a b -> c where (+) :: a -> b -> c {- instance (Integral a, Integral b) => PlusClass a b Expr where a + b = NumExpr (NumOp Plus (Int (fromIntegral a)) (Int (fromIntegral b))) instance Integral a => PlusClass a Double Expr where a + b = NumExpr (NumOp Plus (Int (fromIntegral a)) (Double b)) -} instance PlusClass Integer Integer Expr where a + b = NumExpr (NumOp Plus (Int a) (Int b)) instance PlusClass Double Integer Expr where a + b = NumExpr (NumOp Plus (Double a) (Int b)) instance PlusClass NumExpr NumExpr Expr where a + b = NumExpr (NumOp Plus a b) instance PlusClass Integer NumExpr Expr where a + b = NumExpr (NumOp Plus (Int a) b) instance PlusClass NumExpr Integer Expr where a + b = NumExpr (NumOp Plus a (Int b)) instance PlusClass String String Expr where a + b = StrExpr (StrOp StrPlus (Str a) (Str b)) NumExpr and StrExpr return Expr whereas Int, Double return NumExpr and Str returns StrExpr. This is all so that I could type in input2 = [ InputDecs [ inp "emaLength" TyNumber (20 + 40) ] ] Still, I get the following error Easy/Test/ParserAST.hs:76:44: No instance for (PlusClass t t1 Expr) arising from use of `+' at Easy/Test/ParserAST.hs:76:44-50 Possible fix: add an instance declaration for (PlusClass t t1 Expr) In the third argument of `inp', namely `(20 + 40)' In the expression: inp "emaLength" TyNumber (20 + 40) In the first argument of `InputDecs', namely `[inp "emaLength" TyNumber (20 + 40)]' and get an overlapped instances error if I uncomment the top portion. Any suggestions on how to resolve this? Thanks, Joel -- http://wagerlabs.com/

3 8

Re: Trouble trying to find packages for ubuntu linux
by Chad Scherrer 07 Apr '07

07 Apr '07

Brian, I had this exact problem, and I found this approach to work wonderfully: http://pupeno.com/2006/12/17/unstable-packages-on-ubuntu/ Chad

3 6

Building c2hs on a mac
by manu 06 Apr '07

06 Apr '07

Hello, I'd be interested to know if anybody had managed to build c2hs on a mac recently because I've tried the current darcs version, c2hs-0.14.5, c2hs-0.14.3, c2hs-0.13.6, etc... to no avail I get this with c2hs-0.14.5 : ./Setup.hs configure ./Setup.hs:11:57: Couldn't match expected type `Distribution.PackageDescription.PackageDescription' against inferred type `LocalBuildInfo' Probable cause: `addWrapperAndLib' is applied to too many arguments In the `postInst' field of a record In the first argument of `defaultMainWithHooks', namely `defaultUserHooks {postInst = addWrapperAndLib}' Any help appreciated, thanks E.D

1 0

How can I refactor this code?
by Joel Reymont 06 Apr '07

06 Apr '07

http://hpaste.org/127 It looks quite ugly to me so any help is appreciated! Thanks in advance, Joel -- http://wagerlabs.com/

1 1

Shiqi has Tagged you! :)
by Shiqi Cao 06 Apr '07

06 Apr '07

1 0

ANN: Atom - Yet another Haskell HDL
by Tom Hawkins 05 Apr '07

05 Apr '07

Hi, Haskell has a rich history of embedded hardware description languages. Here's one more for the list. Inspired by the work of Arvind, Hoe, and all the sharp folks at Bluespec, Atom is a small HDL that compiles conditional term rewriting systems down to Verilog RTL. In Atom, a circuit description is composed of a set of state elements (registers) and a set of rules. Each rule has two components: an enabling condition and a collection of actions, or state updates. When a rule is enabled, it's actions may be selected to execute atomically. In contrast to Verilog "always" blocks, multiple rules can write to the same state element. Here's an enabled counter in Atom: counter :: Int -> Signal -> System Signal counter width enable = do count <- reg "count" width 0 rule "updateCount" $ do when enable count <== value count +. one width return $ value count Enjoy! http://funhdl.org/ -Tom A few details: The Atom compiler attempts to maximize the number of rules that can execute in a given clock cycle without breaking the semantics of "one-rule-at-a-time". For simplicity, rules are assigned a global, linear priority. Data dependencies between rules form a graph. A acyclic graph is ideal, because all rules become "sequentially composable". The compiler attempts to order the rules to minimize the number of edges feeding back from lower to higher priority rules. This is equivalent to the feedback arc set problem. (Atom's FAS optimization is pretty poor at the moment.) In a rule-data dependency graph, many of the edges are irrelevent because pairs of rules are often mutually exclusive, ie. can not be enabled at the same time. MiniSat is used to hunt and prune edges from mutually exclusive rules. By only looking back to primary inputs and registers, the SAT procedure is not guaranteed to find all mutually exclusive rules, but it does a pretty good job.

3 2

Automatic derivation (TemplateHaskell?)
by Joel Reymont 05 Apr '07

05 Apr '07

Folks, I have very uniform Parsec code like this and I'm wondering if I can derive it using TemplateHaskell or DrIFT or some other tool. Any ideas? Note that 1) The reserved word matches the constructor 2) No arguments equals no parens 3) More than one argument is separated with a comma 4) For every invocation of numExpr, strExpr or boolExpr, the type of the constructor argument is NumExpr, StrExpr and BoolExpr respectively. This is just a handful of functions and I have to tackle about 100 more, thus my asking :-). Thanks, Joel --- strCall = choice [ do { reserved "NewLine" ; return NewLine } , do { reserved "GetSymbolName" ; return GetSymbolName } , do { reserved "ELDateToString" ; arg1 <- parens numExpr ; return $ ELDateToString arg1 } , do { reserved "TextGetString" ; arg1 <- parens numExpr ; return $ TextGetString arg1 } , do { reserved "Description" ; return Description } , do { reserved "GetExchangeName" ; return GetExchangeName } , do { reserved "LeftStr" ; parens $ do { arg1 <- strExpr ; comma ; arg2 <- numExpr ; return $ LeftStr arg1 arg2 } } , do { reserved "RightStr" ; parens $ do { arg1 <- strExpr ; comma ; arg2 <- numExpr ; return $ RightStr arg1 arg2 } } , do { reserved "LowerStr" ; arg1 <- parens strExpr ; return $ LowerStr arg1 } , do { reserved "UpperStr" ; arg1 <- parens strExpr ; return $ UpperStr arg1 } , do { reserved "Spaces" ; arg1 <- parens numExpr ; return $ Spaces arg1 } , do { reserved "SymbolRoot" ; return SymbolRoot } , do { reserved "MidStr" ; parens $ do { arg1 <- strExpr ; comma ; arg2 <- numExpr ; comma ; arg3 <- numExpr ; return $ MidStr arg1 arg2 arg3 } } , do { reserved "NumToStr" ; parens $ do { arg1 <- numExpr ; comma ; arg2 <- numExpr ; return $ NumToStr arg1 arg2 } } ] -- http://wagerlabs.com/

8 22

Short-circuiting a fold
by Kurt Hutchinson 05 Apr '07

05 Apr '07

Here's a bit of Thursday afternoon fun. Mission: Define "ssfold," a short-circuiting fold. It evaluates to the "folded value" that first satisfies the given predicate. > ssfold :: ( a -> Bool ) -> ( a -> b -> a ) -> a -> [b] -> a Here are two of mine. Straightforward: > ssfold p f z = head . dropWhile ( not . p ) . scanl f z Monadic: > data Done a b = Done { undone :: a } | NotDone b > instance Monad ( Done a ) where > ( NotDone i ) >>= f = f i > ( Done r ) >>= _ = Done r > return = NotDone > > ssfold p f z = undone . foldM (\ v e -> if p v then Done v else NotDone ( f v e ) ) z I want to see some real creativity here, so pull out all the stops. Kurt

4 3

Parsing unordered parameter list with Parsec
by Will Newton 05 Apr '07

05 Apr '07

Hi all, I'm new to Haskell and trying to do some parsing with Parsec. It's been extremely good so far. I have run into a problem I can't seem to see the solution to though. I hope someone on the list can help me out! I have a command with a parameter list like this: CMD PARAM1 foo PARAM2 100 PARAM3 200 Which is easy enough to parse, but it turns out the grammar is not particularly well defined, and it's considered acceptable to swap parameter order round pretty much arbitrarily. Is there a simple way to handle this? I would like to only allow one of each parameter, some parameters may also be optional. It feels like I might have to write my own combinator to do this but I'm not sure I'm quite ready of that yet! Thanks,

2 1

Tracking characters and a timestamp ?
by Marc Weber 05 Apr '07

05 Apr '07

============= ======================================================= {- This program should read characters from stdin, stop on 's' and print the character along with a timestamp You need ghc-6.6 because of Date.Time. When not using mapM addTimeCode I'll get the lines printed on stdout instantly -} import Data.Time.Clock import Data.Time import Control.Monad handleChar :: Show a => (Char, a) -> IO () handleChar ('s', _) = exitWith (ExitFailure 1) handleChar tuple = print tuple addTimeCode a = liftM ( (,) a) getCurrentTime main = do hSetBuffering stdin NoBuffering hGetContents stdin >>= mapM addTimeCode >>= mapM_ handleChar ============= ====================================================== When running and typing a b c it should print ('a', <timestamp>) ('b', <timestamp>) ('c', <timestamp>) It seems to wait till the end of the infinite list. Why? When using a take 10 I'll get those 10 events after having typed the 10th character. Do I need continuation passing style? Would unsafeInterleaveIO help? The final goal is writing a timetracker which sums up the time you've spent on different wmii tags (= you can think of them beeing different screens ) Marc Weber

4 6