fmap (uncurry $ uncurry $ liftM3 foo) ((getA &&& getB) &&& getC) -< ()

i didn’t compile it, it’s 5:25 at night in germany.
goodn8.
- marc

proc _ ->
    do m_a < - getA -< ()
       m_b <- getB -< ()
       m_c <- getC -< ()
       returnA -<
           do a <- m_a
              b <- m_b
              c <- m_c
              return $ foo a b c

And for some reason, I didn't think clearly about that when I did the original example. ]]> http://blog.downstairspeople.org/2009/01/04/maybearrow/comment-page-1/#comment-379 coeus Tue, 20 Jan 2009 03:11:54 +0000 http://blog.downstairspeople.org/?p=53#comment-379 argh! in words: (_,bs) "arrow-left" ( foldr ( "GTGTGT" ) (arr id) $ replicate (length as) (chainlink f) ) -< (as,[]) argh!
in words:

(_,bs)
“arrow-left”
( foldr (
“GTGTGT”
) (arr id) $ replicate (length as) (chainlink f) ) -< (as,[])

what do you mean with heterogeneous parameters?

—–
chainlink :: Arrow (~>) => (a ~> b) -> (([a],[b])~>([a],[b]))
chainlink f = proc (a:ar,br) -> do
b <- f -< a
returnA -< (ar,b:br)

[code]

{-# LANGUAGE Arrows,TypeOperators,EmptyDataDecls #-}
module MaybeArrow where
--import Control.Category hiding ((.),id)
import Control.Arrow
data Thing
data FooThing
data SomeArrow b c
--instance Control.Category.Category SomeArrow where
instance Arrow SomeArrow where
get :: SomeArrow String (Maybe Thing)
get = undefined
foo :: [Thing] -> FooThing
foo = undefined

-- chainlink :: ... -> ((a:ar,br) ~> (ar,b:br))
chainlink :: Arrow (~>) => (a ~> b) -> (([a],[b])~>([a],[b]))
chainlink f = proc (a:ar,br) -> do
b <- f -< a
returnA -)) => (a ~> b) -> [a] -> (() ~> [b])
amap f as = proc x -> do
(_,bs) >>) (arr id) $ replicate (length as) (chainlink f) ) -< (as,[])
returnA -< reverse bs

getAToZ :: SomeArrow () (Maybe FooThing)
getAToZ = amap get [[s]|s>> arr (fmap foo . sequence)

[/code]

but you need the fixed length only ‘inside’ the arrow, not in your sourcecode. so build it!

the idea is to build a chain of equal arrows, which can be simply combined… using lists instead of tuples. each link in that chain is a double list-/stream-transformer. each takes one item from the input list/stream and applies the computed output to the output list/stream. (chainlink)

that chain should process the list of inputs and should generate the list of outputs. (amap)

then on those outputs we have to test wether they all are Just cases… you use the Monad property, which is quite handy, but only if you know some library functions like sequence.

[my next reply shows the code]

well, reading your code above, i guess you still think a tiny bit ‘the imperative way’(tm) …so i advise to read Data.List and half of the paper “Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire (1991)” (http://en.wikipedia.org/wiki/Catamorphism), that will blow most of that tedious imperative style away. it’s about foldr and friends.

regards
- marc

(i’ve just read HWN-100, so this didn’t take 2 weeks.)