override def plus()

in algebird-core/src/main/scala/com/twitter/algebird/GeneratedAbstractAlgebra.scala [3887:3974]
88 lines of code
2 McCabe index (conditional complexity)

  override def plus(
      l: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V),
      r: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)
  ): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) = (
    asemigroup.plus(l._1, r._1),
    bsemigroup.plus(l._2, r._2),
    csemigroup.plus(l._3, r._3),
    dsemigroup.plus(l._4, r._4),
    esemigroup.plus(l._5, r._5),
    fsemigroup.plus(l._6, r._6),
    gsemigroup.plus(l._7, r._7),
    hsemigroup.plus(l._8, r._8),
    isemigroup.plus(l._9, r._9),
    jsemigroup.plus(l._10, r._10),
    ksemigroup.plus(l._11, r._11),
    lsemigroup.plus(l._12, r._12),
    msemigroup.plus(l._13, r._13),
    nsemigroup.plus(l._14, r._14),
    osemigroup.plus(l._15, r._15),
    psemigroup.plus(l._16, r._16),
    qsemigroup.plus(l._17, r._17),
    rsemigroup.plus(l._18, r._18),
    ssemigroup.plus(l._19, r._19),
    tsemigroup.plus(l._20, r._20),
    usemigroup.plus(l._21, r._21),
    vsemigroup.plus(l._22, r._22)
  )
  override def sumOption(
      to: TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)]
  ): Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)] =
    if (to.iterator.isEmpty) None
    else {
      val bufA = fromSumOption[A](1000)
      val bufB = fromSumOption[B](1000)
      val bufC = fromSumOption[C](1000)
      val bufD = fromSumOption[D](1000)
      val bufE = fromSumOption[E](1000)
      val bufF = fromSumOption[F](1000)
      val bufG = fromSumOption[G](1000)
      val bufH = fromSumOption[H](1000)
      val bufI = fromSumOption[I](1000)
      val bufJ = fromSumOption[J](1000)
      val bufK = fromSumOption[K](1000)
      val bufL = fromSumOption[L](1000)
      val bufM = fromSumOption[M](1000)
      val bufN = fromSumOption[N](1000)
      val bufO = fromSumOption[O](1000)
      val bufP = fromSumOption[P](1000)
      val bufQ = fromSumOption[Q](1000)
      val bufR = fromSumOption[R](1000)
      val bufS = fromSumOption[S](1000)
      val bufT = fromSumOption[T](1000)
      val bufU = fromSumOption[U](1000)
      val bufV = fromSumOption[V](1000)
      to.iterator.foreach { tuple =>
        bufA.put(tuple._1); bufB.put(tuple._2); bufC.put(tuple._3); bufD.put(tuple._4); bufE.put(tuple._5);
        bufF.put(tuple._6); bufG.put(tuple._7); bufH.put(tuple._8); bufI.put(tuple._9); bufJ.put(tuple._10);
        bufK.put(tuple._11); bufL.put(tuple._12); bufM.put(tuple._13); bufN.put(tuple._14);
        bufO.put(tuple._15); bufP.put(tuple._16); bufQ.put(tuple._17); bufR.put(tuple._18);
        bufS.put(tuple._19); bufT.put(tuple._20); bufU.put(tuple._21); bufV.put(tuple._22)
      }
      Some(
        (
          bufA.flush.get,
          bufB.flush.get,
          bufC.flush.get,
          bufD.flush.get,
          bufE.flush.get,
          bufF.flush.get,
          bufG.flush.get,
          bufH.flush.get,
          bufI.flush.get,
          bufJ.flush.get,
          bufK.flush.get,
          bufL.flush.get,
          bufM.flush.get,
          bufN.flush.get,
          bufO.flush.get,
          bufP.flush.get,
          bufQ.flush.get,
          bufR.flush.get,
          bufS.flush.get,
          bufT.flush.get,
          bufU.flush.get,
          bufV.flush.get
        )
      )
    }