- Haskell-Cafe - Haskell.org

proper way to generate a random data in criterion
by Kazu Yamamoto 20 Oct '11

20 Oct '11

Hello, I'm measuring performance of the insertion operation of red-black trees. For input, three kinds of [Int] are prepared: the increasing the order, decreasing order, and random. The random case is 4 or 5 times slower than the others. I'm afraid that my program also measured the cost of random Int generation. My benchmark code can be found: https://github.com/kazu-yamamoto/llrbtree/blob/master/bench/insert/Bench.hs Does anyone kindly take a look and tell me whether or not my criterion code measures the cost of random Int generation? If so, would you suggest how to avoid it? Background infromation can be found: Purely Functional Left-Leaning Red-Black Trees http://www.mew.org/~kazu/proj/red-black-tree/ --Kazu

6 8

Comparison Haskell, Java, C and LISP
by yrazes 19 Oct '11

19 Oct '11

Hi, Maybe you remember my case. I was trying to compare some aspects of these languages. Well... I found that I can compare reflection, support for generics, simplicity and safe code. I just want to ask if you have more information for reflection in Haskell. I read that there is no enough for dynamics to support complete reflection. I hope someone can help me this time :) Julita

5 4

Re: [Haskell-cafe] How to implement a digital filter, using Arrows?
by Captain Freako 19 Oct '11

19 Oct '11

Hi John, Thanks for this reply: > Date: Tue, 18 Oct 2011 14:05:22 +1030 > From: John Lask <jvlask(a)hotmail.com> > Subject: Re: [Haskell-cafe] How to implement a digital filter, using > Arrows? > To: haskell-cafe(a)haskell.org > Message-ID: <BLU0- > SMTP384394452FD2750FBE3BCFCC6E50(a)phx.gbl> > Content-Type: text/plain; charset="ISO-8859-1"; format=flowed > > > > your function corresponds with Control.Arrow.Transformer.Automaton. If > you frame your function is such most of your plumbing is taken care of. > Following your advice, I arrived at: 1 {-# LANGUAGE Arrows, GeneralizedNewtypeDeriving, FlexibleContexts #-} 2 3 module Filter ( 4 FilterState 5 , Filter 6 , applyFilter 7 , convT 8 ) where 9 10 import EitherT 11 import Control.Monad 12 import Control.Monad.State 13 import Control.Arrow 14 import Control.Arrow.Operations 15 import Control.Arrow.Transformer 16 import Control.Arrow.Transformer.All 17 import Data.Stream as DS (fromList, toList) 18 19 -- tap weights, `as' and `bs', are being made part of the filter state, in 20 -- order to accomodate adaptive filters (i.e. - DFEs). 21 data FilterState a = FilterState { 22 as :: [a] -- transfer function denominator coefficients 23 , bs :: [a] -- transfer function numerator coefficients 24 , taps :: [a] -- current delay tap stored values 25 } 26 27 -- Future proofing the implementation, using the `newtype' trick. 28 newtype Filter b c = F { 29 runFilter :: (b, FilterState b) -> (c, FilterState b) 31 } 32 33 -- Time domain convolution filter (FIR or IIR), 34 -- expressed in direct form 2 35 convT :: (Num b) => Filter b b 36 convT = F $ \(x, s) -> 37 let wk = (x - sum [a * t | (a, t) <- zip (tail $ as s) (taps s)]) 38 newTaps = wk : ((reverse . tail . reverse) $ taps s) 39 s' = s {taps = newTaps} 40 y = sum [b * w | (b, w) <- zip (bs s) (wk : (taps s))] 41 in (y, s') 42 43 -- Turn a filter into an Automaton, in order to use the built in plubming 44 -- of Arrows to run the filter on an input. 45 filterAuto :: (ArrowApply a) => Filter b c -> FilterState b -> Automaton a (e, b) c 46 filterAuto f s = Automaton a where 47 a = proc (e, x) -> do 48 (y, s') <- arr (runFilter f) -< (x, s) 49 returnA -< (y, filterAuto f s') 50 53 applyFilter :: Filter b c -> FilterState b -> [b] -> ([c], FilterState b) 54 applyFilter f s = 55 let a = filterAuto f s 56 in proc xs -> do 57 ys <- runAutomaton a -< ((), DS.fromList xs) 58 s' <- (|fetch|) 59 returnA -< (DS.toList ys, s') 60 which gave me this compile error: > Filter.hs:58:16: > Could not deduce (ArrowState (FilterState b) (->)) > from the context () > arising from a use of `fetch' at Filter.hs:58:16-20 > Possible fix: > add (ArrowState (FilterState b) (->)) to the context of > the type signature for `applyFilter' > or add an instance declaration for > (ArrowState (FilterState b) (->)) > In the expression: fetch > In the expression: > proc xs -> do { ys <- runAutomaton a -< ((), fromList xs); > s' <- (|fetch |); > returnA -< (toList ys, s') } > In the expression: > let a = filterAuto f s > in > proc xs -> do { ys <- runAutomaton a -< ((), fromList xs); > s' <- (|fetch |); > .... } > So, I made this change: 51 applyFilter :: *(ArrowState (FilterState b) (->)) =>* Filter b c -> FilterState b -> [b] -> 52 ([c], FilterState b) And that compiled. However, when I tried to test my new filter with: > let s = FilterState [1,0,0] [0.7, 0.2, 0.1] [0, 0, 0] > applyFilter convT s [1,0,0,0,0] I got: > <interactive>:1:0: > No instance for (ArrowState (FilterState Double) (->)) > arising from a use of `applyFilter' at <interactive>:1:0-30 > Possible fix: > add an instance declaration for > (ArrowState (FilterState Double) (->)) > In the expression: applyFilter convT s [1, 0, 0, 0, ....] > In the definition of `it': it = applyFilter convT s [1, 0, 0, ....] > I thought, "maybe, I need to derive from *ArrowState* in my *Filter* type definition." So, I tried making this change to the code: 28 newtype Filter b c = F { 29 runFilter :: (b, FilterState b) -> (c, FilterState b) 30 } deriving (ArrowState (FilterState x)) but then I was back to no compile: > Filter.hs:30:14: > Can't make a derived instance of > `ArrowState (FilterState x) Filter' > (even with cunning newtype deriving): > cannot eta-reduce the representation type enough > In the newtype declaration for `Filter' > Do you have any advice? Thanks, -db

3 2

subclasses and classes with same type in instance
by Patrick Browne 18 Oct '11

18 Oct '11

2 1

Waiting on input with `hWaitForInput' or `threadWaitRead'
by Jason Dusek 18 Oct '11

18 Oct '11

I would like to use evented I/O for a proxying application. My present thinking is to fork a thread for each new connection and then to wait for data on either socket in this thread, writing to one or the other socket as needed. There are two API functions I've found for waiting and they each raise some questions: System.IO.hWaitForInput :: Handle -> Int -> IO Bool This function dovetails well with the high-level networking libraries but introduces difficulties because it decodes the stream to check for full characters. If the handle is set to binary mode, are decoding errors still a possibility? Control.Concurrent.threadWaitRead :: Fd -> IO () This function would seem to be closer to the ideal in terms of performance and semantics: it just waits until there are bytes available. However, converting the handle produced by the high-level networking libraries to a file descriptor closes the handle (!). This makes some sense: plucking the descriptor out of a handle doubtless interacts with other users of that handle in an unsafe way. It seems I need to through a very different set of libraries, one based on file descriptors and not handles, to be able to use this function. Ideally, I'd get something like select() on handles, just saying whether there are bytes or not. However, I haven't managed to find anything like that in the standard libraries. -- Jason Dusek () ascii ribbon campaign - against html e-mail /\ www.asciiribbon.org - against proprietary attachments

4 10

hello Haskell
by R J 18 Oct '11

18 Oct '11

hey Haskell check it out http://www.fastnews10i.com

2 1

Fwd: GHC as a library error.
by Paulo Pocinho 18 Oct '11

18 Oct '11

Forwarding to Haskell-Cafe: I'm trying GHC as a library, as documented in: http://www.haskell.org/haskellwiki/GHC/As_a_library http://www.haskell.org/ghc/docs/7.2.1/html/users_guide/ghc-as-a-library.html However, this code: import GHC import GHC.Paths ( libdir ) import DynFlags ( defaultDynFlags ) main = defaultErrorHandler defaultDynFlags $ do runGhc (Just libdir) $ do dflags <- getSessionDynFlags setSessionDynFlags dflags target <- guessTarget "test_main.hs" Nothing setTargets [target] load LoadAllTargets Produces: Couldn't match expected type `Severity' with actual type `DynFlags.Settings' Expected type: DynFlags.LogAction Actual type: DynFlags.Settings -> DynFlags In the first argument of `defaultErrorHandler', namely `defaultDynFlags' In the expression: defaultErrorHandler defaultDynFlags How can I fix it? Note: this was on a fresh install with latest stable GHC installer 7.2.1.

2 2

About the ConstraintKinds extension
by bob zhang 18 Oct '11

18 Oct '11

Hi cafe, I have played quite a bit with the ConstraintKinds extension, pretty cool. But I found a problem which I thought would be made better, plz correct me if I am wrong take a contrived example, class C B => B a where here B :: * -> Constraint, I think this definition is reasonable, since B does not appears in the first position of the context. Previously, we require acyclic class declarations since we don't have ConstraintKinds extension but now since type class could be abstracted, I think the definition above should be ok. the ghc-manual cited the program below is valid class C a where { op :: D b => a -> b -> b } class C a => D a where { ... } I think there are no reasons to reject class C B => B where (and this style is pretty useful in some cases) ... B :: * -> Constraint C :: (*->Constraint) -> Constraint Any comments are welcome -- Best, bob

2 1

How to implement a digital filter, using Arrows?
by Captain Freako 18 Oct '11

18 Oct '11

Hi all, If I have a pure function, which maps `(input, initialState)' to `(output, nextState)', what's the most succinct way of constructing a digital filter from this function, using Arrows? Thanks, -db

2 1

Question on `runState'
by Captain Freako 18 Oct '11

18 Oct '11

In this excerpt from the `StateArrow' page: runState :: Arrow<http://hackage.haskell.org/packages/archive/base/4.2.0.2/doc/html/Control-A…>a => StateArrow<http://hackage.haskell.org/packages/archive/arrows/0.4.1.2/doc/html/Control…>s a *e* b -> a (e, s) (b, s)Source<http://hackage.haskell.org/packages/archive/arrows/0.4.1.2/doc/html/src/Con…> what's the significance of having written "StateArrow s a *e* b", instead of "StateArrow s a b c"? Thanks, -db

3 2