FP - sequence :: Seq[Try[T]] to Try[Seq[T]]

sequence.scala

import scala.util.Try

implicit class SeqTryExtension[T](seq: Seq[Try[T]]) {
  def sequence: Try[Seq[T]] =
    seq
      .foldRight(Try(List.empty[T])) {
        case (item, acc) => for { a <- acc; i<- item } yield i :: a
      }
}

implicit class MapStringTryExtension[T](map: Map[String, Try[T]]) {
  import scala.collection.mutable.LinkedHashMap
  implicit def sequence: Try[LinkedHashMap[String, T]] =
    map
      .foldRight(Try(LinkedHashMap.empty[String,T])) {
        case (item, acc) => for { a <- acc; i<- item._2 } yield LinkedHashMap(item._1 -> i) ++ a
      }
}

import scala.util.{Try,Success,Failure}

// tests for Seq
val sf = Seq(Success(1), Success(2), Failure(new RuntimeException("not a number")), Success(4), Success(5))
val ss = Seq(Success(1), Success(2), Success(3), Success(4), Success(5))
println(tf.sequence)
println(tssequence)

// tests for Map
val mf = Map("a" -> Success("a"), "b" -> Success("b"), "c" -> Failure(new RuntimeException("failure")), "d" -> Success("d"))
val ms = Map("a" -> Success("a"), "b" -> Success("b"), "c" -> Success("c"), "d" -> Success("d"))
println(mf.sequence)
println(ms.sequence)

Prints:

sf: scala.util.Try[Seq[Int]] = Failure((java.lang.RuntimeException: not a number)
ss: scala.util.Try[Seq[Int]] = Success(List(1, 2, 3, 4, 5))

mf: scala.util.Try[scala.collection.mutable.LinkedHashMap[String,String]] = Failure(java.lang.RuntimeException: failure)
ms: scala.util.Try[scala.collection.mutable.LinkedHashMap[String,String]] = Success(Map(a -> a, b -> b, c -> c, d -> d))