[Haskell-cafe] Accumulating and threading output of functions

[MigMit]

First of all: where does your first argument (`a`) come from? Is it the same for all of those functions?

If so, you can get rid of it by using `map ($ a)`.

Now, you have a list of functions of type `b -> (b, c)`. The most natural thing here is to convert them to the State monad: `State b c`. And your original functions would be `a -> State b c`. Try to use State monad from the start.

Then, from the list of type `[State b c]`, the `sequence` function gives you `State b [c]` instead. `evalState` would give you just `[c]`, and you can convert the list of `c`s into a single `c` in any way you want.

> On 04 Jun 2016, at 17:18, martin <martin.drautzburg at web.de> wrote:
> 
> Hello all,
> 
> I have a number of functions, whose type is something like this:
> 
> f:: a -> b -> (b, c)
> 
> i.e. it returns a modified b and an additional c.
> 
> Now I want to write a combinator, which assembles a list of such functions into a single one. This combinator will have
> to thread the bs from one function to the next and accumulate the cs into a single c.
> 
> While I was able to write this using a fold, I am not happy with it (my first attempt had a bad error in it, which is
> always a bad sign).
> 
> Are you aware of any idioms, how to do such things on the beaten track?
> 
> 
> 
> 
> 
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe