- Haskell-Cafe - Haskell.org

Re: Is logBase right?
by Steve 28 Aug '09

28 Aug '09

On Sat, 2009-08-22 at 13:03 -0400, haskell-cafe-request(a)haskell.org wrote: > Message: 10 > Date: Sat, 22 Aug 2009 11:24:21 +0200 > From: Roberto L?pez <plastermoso(a)hotmail.com> > Subject: [Haskell-cafe] Re: Is logBase right? > To: haskell-cafe(a)haskell.org > Message-ID: <h6odg8%2493j%241(a)ger.gmane.org> > Content-Type: text/plain; charset="ISO-8859-1" > > If 4.0 / 2.0 was 1.9999999999999999999998, it would be ok? > > The real value of log10 1000 is 3 (3.0). It can be represented with > accuracy > and it should be. > > You get the accuracy value in Perl, but there is the same problem in > Python. > It's a bit discouraging. > There is *not* the same problem in Python: $ python Python 2.6.2 (r262:71600, Jul 9 2009, 23:16:53) [GCC 4.4.0 20090506 (Red Hat 4.4.0-4)] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import math >>> math.log10(1000) 3.0 Recent work in Python 3 (and Python 2.6) has improved the handling of floating point numbers, and addresses exactly the problem that Roberto has raised. I see no reason why Haskell could not improve its handling of floating point numbers by using similar techniques. Steve

9 13

Time constrained computation
by Mitar 28 Aug '09

28 Aug '09

Hi! I am not really sure if this is correct term for it but I am open to better (search) terms. pure

4 4

strictness analysis on algebraic data types
by Peter Verswyvelen 28 Aug '09

28 Aug '09

I'm reading the book "Modern Compiler Design<http://www.cs.vu.nl/~dick/MCD.html>", and in the chapter about functional programming it is stated that strictness analysis in the presence of ADTs (aka records) is a very hard problem to tackle. I'm not sure what the current state of art is here (e.g GHC or JHC), and don't understand what the problem is. Does it mean that it's a good idea to carefully consider when to make data constructor arguments (aka fields) strict, since the compiler can't do good strictness analysis when it encounters say a record with many lazy fields?

1 0

Arrows extentions and ArrowApplicable
by Maciej Piechotka 28 Aug '09

28 Aug '09

Arrows syntax supports Arrow, ArrowChoice(if, case etc.) and ArrowLoop(rec) - but not ArrowApplicable. Therefore it is not possible to write: proc x -> do a <- someArrow -< x a -< x but proc x -> do a <- someArrow -< x app -< (a, x) and proc x -> do a <- someArrow -< x app -< (otherArrow a, x) instead of proc x -> do a <- someArrow -< x otherArrow a -< x Such approach adds some syntax sugar but without adding any additional keyword and IMHO it can simplify writing ArrowApply (especially Kleisli IO). Regards

2 1

Mapping over multiple values of a list at once?
by haskell＠kudling.de 28 Aug '09

28 Aug '09

Hi, Imagine you have a list with n-values. You are asked to iterate over the list and calculate the average value of each 3 neighbouring values. For example, starting from [4,3,2,6,7] you need to find the averages of 4,3,2 and 3,2,6 and 2,6,7 resulting in [3,4,5] What is the most elegant way to do that? The naive ansatz to use "(!!") excessively sounds pretty inefficient. Bye, Lenny

8 8

Uninstall a cabal package?
by Colin Paul Adams 28 Aug '09

28 Aug '09

What is the procedure to uninstall a cabal package? -- Colin Adams Preston Lancashire

2 2

tomorrow: Edinburgh Meetup (Sat 29 Aug) and Hack Day (Sun 30 Aug)
by Eric Y. Kow 28 Aug '09

28 Aug '09

Dear Haskellers, Last minute reminder: We will be having a Hack Day in Edinburgh on Sunday 30 August (ICFP venue). That's this weekend! For the interested, we will also be meeting up the day before 09:30 Saturday 29 August just outside the RCPE (ie. the ICFP venue again). We'll have a quick wander and hopefully find some nice places to sit, chat and hack. On Sunday the real Hack Day begins at the ICFP venue, rooms 4/5. http://www.haskell.org/haskellwiki/Hac7 And for the interested, Brent says: > I'll be there Saturday morning---looking forward to meeting people! > > Also, I have purchased a ticket to hear a concert of some 16th-century > a capella 16th-century music at the Canongate Kirk at 5pm on Saturday: > > http://www.edfringe.com/ticketing/detail.php?id=13649 > > Just thought I'd mention it, so if there's anyone else coming to the > meetup day and 16th-century a capella sounds like your cup of tea, you > can get a ticket too and we can go together. Looking forward to seeing you, Eric PS. Bring a name tag if you've got one. There are about 15 people registered so far. It's not too late to register! (yes, you could also just drop by...) -- Eric Kow <http://www.nltg.brighton.ac.uk/home/Eric.Kow> PGP Key ID: 08AC04F9

1 0

Applicative and Monad transformers
by Jeremy Shaw 28 Aug '09

28 Aug '09

Hello, I have seen it said that all Monads are Applicative Functors because you can just do: instance (Monad f, Applicative f) => Applicative (ReaderT r f) where pure = return (<*>) = ap However, that instance for ReaderT does not exhibit the properties I was hoping for. By substitution the definition of ap: ap :: (Monad m) => m (a -> b) -> m a -> m b ap = liftM2 id liftM2 :: (Monad m) => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r liftM2 f m1 m2 = do { x1 <- m1; x2 <- m2; return (f x1 x2) } we see that it becomes: instance (Monad f, Applicative f) => Applicative (ReaderT r f) where pure = return f <*> x = do { f' <- f; x' <- x; return (f' x') } What I would prefer is: instance (Monad f, Applicative f) => Applicative (ReaderT r f) where pure a = ReaderT $ const (pure a) f <*> a = ReaderT $ \r -> ((runReaderT f r) <*> (runReaderT a r)) I assume that only one version is correct, but I am having a hard time figuring out which one. I have attached a file which shows my motivation for prefering the second variation. There is a 'looker' function which does three lookups and combines the results using the Applicative Functor. With the first Applicative instance for ReaderT you will only get a failure message for the first lookup that fails -- which is what you expect with monadic behaviour. With the second instance, you get back a list of all the lookups that failed, which seems like what I would expect with Applicative Functor behaviour. Thanks! - jeremy {-# LANGUAGE FlexibleContexts, FlexibleInstances #-} module Main where import Control.Applicative (Applicative((<*>), pure), (<$>)) import Control.Monad (Monad((>>=), return), ap) import Control.Monad.Reader (MonadReader(ask, local), ReaderT(ReaderT, runReaderT)) import Data.Monoid(Monoid(mappend)) instance (Monad f, Applicative f) => Applicative (ReaderT r f) where pure = return (<*>) = ap {- instance (Monad f, Applicative f) => Applicative (ReaderT r f) where pure a = ReaderT $ const (pure a) f <*> a = ReaderT $ \r -> ((runReaderT f r) <*> (runReaderT a r)) -} instance (Monoid e) => Applicative (Either e) where pure = Right (Left errF) <*> (Left errA) = Left (errF `mappend` errA) (Left err) <*> _ = Left err _ <*> (Left err) = Left err (Right f) <*> (Right a) = Right (f a) instance Monad (Either [String]) where return = Right (Right a) >>= f = f a (Left e) >>= f = (Left e) fail str = Left [str] lookupE :: (Eq a) => a -> [(a,b)] -> (Either a b) lookupE a env = case lookup a env of Just b -> Right b Nothing -> Left a look :: String -> ReaderT [(String,b)] (Either [String]) b look a = do env <- ask case lookup a env of Just b -> return b Nothing -> fail a looker :: ReaderT [(String, Int)] (Either [String]) (Int, Int, Int) looker = ((,,) <$> look "foo" <*> look "bar" <*> look "baz") test :: Either [String] (Int, Int, Int) test = runReaderT looker [("bar", 1)]

6 8

ANNOUNCE: jhc 0.7.1
by John Meacham 27 Aug '09

27 Aug '09

Hi, I am happy to announce the jhc optimizing haskell compiler version 0.7.1. Information on installing jhc is here: http://repetae.net/computer/jhc/building.shtml And the Main page is here: http://repetae.net/computer/jhc There have been a lot of changes since the last public release, Some notable ones are: * The use of a general compiler cache by default rather than object files. This means work done by jhc is shared between projects, jhc uses cryptographic hashes internally to never compile the same piece of code more than once. This has numerous benefits, a notable one being speed. * Reworked library support. Jhc libraries are now much more general, when linking only the bits needed are loaded from the hl file, libraries are allowed to re-export modules from other libraries, making versioning or providing multiple interfaces to the same functionality a lot simpler. Library conflicts are 'lazy', like ambiguity errors now. * Updated Manual, clearer build instructions * Support for writing pure C libraries in Haskell. * numerous library updates, filled out many IO routines that were stubs before * Smart progress meters when compiler for a better user experience * performs all typechecking before compilation, for a faster edit-compile loop when writing code with jhc. * various bug fixes * Cross Compilation improvements, for instance you can compile for windows transparently on a linux box. Or for an embedded target that is independent of the host. * Better Mac OSX Support, as both a host and target. If you are wondering about the large version number bump since the last release, It is because several versions were released only internally to the jhc list for testing. If you are interested in jhc, join the list at: http://www.haskell.org/mailman/listinfo/jhc John -- John Meacham - ⑆repetae.net⑆john⑈ - http://notanumber.net/

5 5

Killing a thread blocking on a foreign call
by John Van Enk 27 Aug '09

27 Aug '09

Hi List, I'm trying to kill a thread (during program cleanup) that is almost always going to be perma-blocking on a foreign call (read). It seems that there's no facility to do this built into Haskell at this point, or is there? /jve

1 0