Alfredo Di Napoli | 3 Oct 10:41 2012
Picon

Explicitly passing an argument to an arrow

Hello everyone,


sorry for the dumb question but I'm wrapping my head around arrow just from this morning.
Consider this toy function to swap argument of a tuple:

swapA' :: (Arrow a) => a ((b,c), (b,c)) (c,b)
swapA' = swapFirst >>> swapSecond
  where
    swapFirst  = first $ arr snd
    swapSecond = second $ arr fst

It works but requires to pass a tuple of tuple, namely ((b,c), (b,c)).
How can I explicitly pass my tuple of tuple to swapFirst so I can simply invoke

swapA' (1,2) 

and get the correct result?

ps. I know that swap can be easily and elegantly be written as:

swap = snd &&& fst

but the point of the exercise was to experiment with first, second and arrow concatenation

Thanks in advance,
Alfredo
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
Brent Yorgey | 3 Oct 12:55 2012

Re: Explicitly passing an argument to an arrow

On Wed, Oct 03, 2012 at 10:41:25AM +0200, Alfredo Di Napoli wrote:
> Hello everyone,
> 
> sorry for the dumb question but I'm wrapping my head around arrow just from
> this morning.
> Consider this toy function to swap argument of a tuple:
> 
> swapA' :: (Arrow a) => a ((b,c), (b,c)) (c,b)
> swapA' = swapFirst >>> swapSecond
>   where
>     swapFirst  = first $ arr snd
>     swapSecond = second $ arr fst
> 
> 
> It works but requires to pass a tuple of tuple, namely ((b,c), (b,c)).
> How can I explicitly pass my tuple of tuple to swapFirst so I can simply
> invoke
> 
> swapA' (1,2)
> 
> 
> and get the correct result?

Like this?

  swapA' = dup >>> swapFirst >>> swapSecond
    where
      dup = id &&& id
      ...

I'm afraid I'm not confident I really understand your question,
however, so if that doesn't answer it, try asking again!

-Brent
Alfredo Di Napoli | 3 Oct 13:03 2012
Picon

Re: Explicitly passing an argument to an arrow

Thanks Brent, this should do the trick, although what I was asking was something more general:


For "explicitly pass" I meant passing them without the eta reduce, in other terms:

swapA' :: (Arrow a) => a ((b,c), (b,c)) (c,b)
swapA'  t = (????) swapFirst >>> swapSecond (???)
  where
    swapFirst  = first $ arr snd
    swapSecond = second $ arr fst

 where the question marks indicate that I don't know how to tell swapFirst "hey, even though from the outside
I'm passing you a tuple *t*, you have to take as input a (t,t)."

Hope this is clearer or it has some sense at all, maybe I'm not getting correctly the way arrows work!

bye,
A.


Like this?

  swapA' = dup >>> swapFirst >>> swapSecond
    where
      dup = id &&& id
      ...

I'm afraid I'm not confident I really understand your question,
however, so if that doesn't answer it, try asking again!

-Brent

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
Ertugrul Söylemez | 3 Oct 14:11 2012
Picon

Re: Explicitly passing an argument to an arrow

Alfredo Di Napoli <alfredo.dinapoli <at> gmail.com> wrote:

> Thanks Brent, this should do the trick, although what I was asking was
> something more general:
>
> For "explicitly pass" I meant passing them without the eta reduce, in
> other terms:
>
> swapA' :: (Arrow a) => a ((b,c), (b,c)) (c,b)
> swapA'  t = (????) swapFirst >>> swapSecond (???)
>   where
>     swapFirst  = first $ arr snd
>     swapSecond = second $ arr fst
>
>  where the question marks indicate that I don't know how to tell
> swapFirst "hey, even though from the outside
> I'm passing you a tuple *t*, you have to take as input a (t,t)."
>
> Hope this is clearer or it has some sense at all, maybe I'm not
> getting correctly the way arrows work!

Perhaps arrow notation (Arrows extension) is what you want:

    swapA' :: (Arrow a) => a ((b, c), (b, c)) (c, b)
    swapA' =
        proc ((_, x), (y, _)) -> id -< (x, y)

But I really don't understand why you're implementing this as an arrow
computation.  A simple function would do the trick, and should you
really want to use it in an arrow you can just lift it by applying
'arr'.

Greets,
Ertugrul

--

-- 
Not to be or to be and (not to be or to be and (not to be or to be and
(not to be or to be and ... that is the list monad.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Gmane