Wouldn't it be better to make an instance of the Boolean class for functions, that way you could just write: filter ((< 0.5) && (> -0.5)) xs Not sure about the syntax, as the Haskell site is down. Also it will require that you install and import the Boolean class. One could ask if any of these methods are more readable than the original though. Paul Heinrich Apfelmus wrote:

Michael Mossey wrote:

...

Is there a nifty way to write

filter (\x -> x < 0.5 && x > -0.5) xs

without explicitly using x?

Maybe arrows? I have a vague understanding that arrows can "send" an argument to more than one computation.

That's a job for the reader monad.

Lambda Fu, form 53 - silent reader of truth

import Control.Monad import Control.Monad.Reader

filter (liftM2 (&&) (< 0.5) (> -0.5)) xs

Regards, apfelmus

-- http://apfelmus.nfshost.com

_______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners

Heinrich Apfelmus wrote:

Michael Mossey wrote:

...

Is there a nifty way to write

filter (\x -> x < 0.5 && x > -0.5) xs

without explicitly using x?

Maybe arrows? I have a vague understanding that arrows can "send" an argument to more than one computation.

That's a job for the reader monad.

Lambda Fu, form 53 - silent reader of truth

import Control.Monad import Control.Monad.Reader

filter (liftM2 (&&) (< 0.5) (> -0.5)) xs

Cool. I realized there was a way to think about this. I haven't used the reader monad in my own projects, but I recall it's one way to pass the same value into several functions: headTail = do h <- head t <- tail return (h,t) headTail "foo" = ('f',"oo") Note also there's no need for runReader or evalReader (at least not that I'm aware of) because unlike other monads, the reader monad is itself a function that takes the state to be read. This could be generalized to headTail2 g = do h <- head t <- tail return $ g h t headTail2 (,) "foo" = ('f',"oo") But this form: do { x <- m1; y <- m2; return $ g x y} is exactly the definition of liftM2. Specifically, liftM2 g m1 m2.

Brent Yorgey wrote:

Note that little-r 'reader' is just an informal name for the ((->) e) monad, which is what your code was using. Control.Monad.Reader also provides the big-R 'Reader' type, which is just a newtype wrapper around a little-r reader, and does indeed have a 'runReader' method (which just removes the newtype constructor). That is,

newtype Reader r a = Reader { runReader :: r -> a }

C.M.Reader also provides ReaderT, a monad transformer version of Reader.

I thought Control.Monad.Reader also provides the needed instance Monad ((->) r) but this is actually provided by Control.Monad.Instances . Regards, apfelmus -- http://apfelmus.nfshost.com

On Mon, Oct 19, 2009 at 12:07:19PM +0200, Christian Maeder wrote:

Michael Mossey schrieb:

...

Is there a nifty way to write

filter (\x -> x < 0.5 && x > -0.5) xs

without explicitly using x?

Hoogle did not find a function of type:

(b -> b -> b) -> (a -> b) -> (a -> b) -> a -> b

or (b -> c -> d) -> (a -> b) -> (a -> c) -> a -> d

Apparently Hoogle does not know to try unifying m b with a -> b. As others have pointed out, a function of this type (actually, a more general type) does exist, namely, liftM2. -Brent

Carl Cravens wrote:

Michael Mossey wrote:

...

Is there a nifty way to write

filter (\x -> x < 0.5 && x > -0.5) xs

without explicitly using x?

I'm pretty new to Haskell... are you looking for a *better* way to write this, or is this an exercise in exploring alternatives for the sake of understanding?

Hi Carl, Either one. Let me chime in with some observations from a few months of studying Haskell. (Brent and Apfelmus can probably elaborate on this.) Eliminating variables and working with function combinations has benefits. The one suggestion I've seen here that seems to be right on the money is liftM2 (&&) (< 0.5) (> -0.5) Although that might seem less clear to a beginner, it is actually _more_ clear than the lambda function in some ways. It's easier to work with proof at a more abstract level like this, and strange as it may seem, what I seem to observe in expert users of Haskell is that their brains will pick up what this is doing faster than the lambda function. Or maybe this example is too small to be meaningful, but this kind of abstraction is the direction I want to move in, for there are benefits waiting for me when I arrive. The Parsec library is an example of how concise and elegant code can get when you choose your abstractions carefully. -Mike

Am Dienstag 20 Oktober 2009 04:48:50 schrieb Michael Mossey:

Carl Cravens wrote:

...

Michael Mossey wrote:

...

Is there a nifty way to write

filter (\x -> x < 0.5 && x > -0.5) xs

without explicitly using x?

I'm pretty new to Haskell... are you looking for a *better* way to write this, or is this an exercise in exploring alternatives for the sake of understanding?

Hi Carl,

Either one.

Let me chime in with some observations from a few months of studying Haskell. (Brent and Apfelmus can probably elaborate on this.)

Eliminating variables and working with function combinations has benefits.

But it's not unconditionally a good thing. If you exaggerate it, it's pure obfuscation. Nevertheless, playing around with eliminating variables and using combinators even beyond the border of obfuscation is a good exercise. You gain understanding and a feeling of when it's better to stop by that.

The one suggestion I've seen here that seems to be right on the money is

liftM2 (&&) (< 0.5) (> -0.5)

May I offer (&&) <$> (< 0.5) <*> (> -0.5) ? It works on Applicative Functors (doesn't need the full force of Monads).

Although that might seem less clear to a beginner, it is actually _more_ clear than the lambda function in some ways. It's easier to work with proof at a more abstract level like this, and strange as it may seem, what I seem to observe in expert users of Haskell is that their brains will pick up what this is doing faster than the lambda function.

In this small example, both are immediately clear, you need more complicated lambda expressions to get a measurable difference :)

On Tue, Oct 20, 2009 at 5:28 AM, Daniel Fischer wrote:

May I offer

(&&) <$> (< 0.5) <*> (> -0.5)

or: import Control.Applicative.Infix between l h = (> l) <^ (&&) ^> (< h) Bas You can find Control.Applicative.Infix in InfixApplicative: http://hackage.haskell.org/package/InfixApplicative

Am Freitag 23 Oktober 2009 16:25:57 schrieb pl:

filter ((<=0.5) . abs) xs

Would be filter ((< 0.5) . abs). Yes, it's fine. However, if the range is not symmetrical about 0, this is not so nice anymore: cap lo hi = filter (\x -> lo < x && x < hi) cap lo hi = filter (liftM2 (&&) (lo <) (< hi)) cap lo hi = filter ((&&) <$> (lo <) <*> (< hi)) cap lo hi = filter ((< halflength) . abs . subtract mid) where mid = (lo+hi)/2 halflength = (hi-lo)/2

On Mon, Oct 19, 2009 at 10:49 AM, Michael Mossey wrote:

...

Is there a nifty way to write

filter (\x -> x < 0.5 && x > -0.5) xs

without explicitly using x?

Maybe arrows? I have a vague understanding that arrows can "send" an argument to more than one computation.

-Mike

Am Freitag 23 Oktober 2009 17:25:57 schrieb Darrin Thompson:

On Fri, Oct 23, 2009 at 10:25 AM, pl wrote:

...

   filter ((<=0.5) . abs) xs

pure (&&) <*> (< 0.5) <*> (> -0.5)

liftM2 (&&) (< 0.5) (> -0.5)

Someone suggested that this was an example of the reader monad but I don't get that.

It's because ((->) r) *is* the reader monad. Control.Monad.Reader's Reader r a is just that wrapped in a newtype: newtype Reader r a = Reader { runReader :: r -> a }

...

:i (->)

data (->) a b -- Defined in GHC.Prim instance Monad ((->) r) -- Defined in Control.Monad.Instances instance Functor ((->) r) -- Defined in Control.Monad.Instances instance Applicative ((->) a) -- Defined in Control.Applicative

That's what I see working here.

-- Darrin