G>>Нет, как раз именно это и не является протаскиванием состояния. Протянутое состояние невозможно выразить в терминах comprehensions.

"Протягивание состояния" — термин, обозначающий общую технику избавления от явного состояния, состоящую в передаче и транформации данных через последовательность вызовов, передаваемых и возвращаемых отдельным параметром через все вызовы.

Простейший пример — у меня есть цикл, который суммирует массив во внутренней мутабельной переменной. Она — является состоянием. Как мне от него избавиться? Преобразовать цикл в рекурсию, и передовать значение текущей суммы через параметр функции. Эта переменная — и есть "протянутое состояние".

L>Ты именно так и предлагаешь по сути делать. Только это протягивание будет не на этапе fold-а, а переде ним, там где ьы собрался делать склейку. В fold придет уже придет последовательность с нужными данными, но сформированы они как раз будет все через то же протягивание.

const = 5

    static Dictionary<string, List<Percent>> CalcPercents2(
        ProvidingVolume[] providingVolumes, ReceivingVolume[] receivingVolumes)
    {
      Dictionary<string, List<ProvidingVolume>> providingGroup = new Dictionary<string, List<ProvidingVolume>>();
      foreach (ProvidingVolume pv in providingVolumes)
        providingGroup.GetOrCreateValue(pv.Provider).Add(pv);

      Dictionary<string, List<ReceivingVolume>> receivingGroup = new Dictionary<string, List<ReceivingVolume>>();
      foreach (ReceivingVolume rv in receivingVolumes)
        receivingGroup.GetOrCreateValue(rv.Account).Add(rv);

      Dictionary<string, double> receivingSum = new Dictionary<string, double>();
      foreach (List<ReceivingVolume> list in receivingGroup.Values)
        receivingSum[list[0].Account] = list.Sum(delegate(ReceivingVolume rv) { return rv.Volume; });

      Dictionary<string, List<Percent>> percents = new Dictionary<string, List<Percent>>();
      foreach (List<ProvidingVolume> list in providingGroup.Values)
      {
        double sum = list.Sum(delegate(ProvidingVolume pv) { return pv.Volume; });

        foreach (ProvidingVolume pv in list)
        {
          List<ReceivingVolume> rv = receivingGroup.FindObject(pv.Account);
          if (rv != null)
          {
            foreach (ReceivingVolume r in rv)
            {
              Percent percent = new Percent();
              percent.Provider = pv.Provider;
              percent.Receiver = r.Receiver;
              percent.Account = pv.Account;
              percent.Value = pv.Volume / sum * r.Volume / receivingSum[r.Account];

              percents.GetOrCreateValue(percent.Provider).Add(percent);
            }
          }
        }
      }

      return percents;
    }

        static Dictionary<string, List<Percent>> CalcPercents(
            ProvidingVolume[] providingVolumes, ReceivingVolume[] receivingVolumes)
        {
            var percents = 
                from percent in
                    from prov in
                        from p in providingVolumes
                        group p by p.Provider into pg
                        let total = pg.Sum(v => v.Volume)
                        from pp in pg
                        select new { pp, total }
                    join rec in
                        from r in receivingVolumes
                        group r by r.Account into rg
                        let total = rg.Sum(v => v.Volume)
                        from rr in rg
                        select new { rr, total }
                    on prov.pp.Account equals rec.rr.Account
                    select new Percent
                    {
                        Provider = prov.pp.Provider,
                        Receiver = rec.rr.Receiver,
                        Account  = prov.pp.Account,
                        Value    = prov.pp.Volume / prov.total * rec.rr.Volume / rec.total
                    }
                group percent by percent.Provider;

            return percents.ToDictionary(p => p.Key, p => p.ToList());
        }

public static M<B> SelectMany<M, A, B>(this M<A> m, Func<A, M<B>> k)

L>public static M<B> SelectMany<M, A, B>(this M<A> m, Func<A, M<B>> k)
L>

class C<T>
{
   public C<V> SelectMany<U,V>(Func<T,C<U>> selector,
        Func<T,U,V> resultSelector);
}

public C<V> SelectMany<U,V>(this C<T> source, Func<T,C<U>> selector,
        Func<T,U,V> resultSelector);