Report a status based on a list of results
Something like this maybe?

  @tailrec
  def trf(
    results: List[CreateResult.Result],
    conf: Option[CreateAllResult.Conflict] = None,
    nf:   Option[CreateAllResult.NotFound] = None, 
    f:    Option[CreateAllResult.Failed] = None, 
    defs: List[ChecklistRuleDefinition] = Nil
  ): List[CreateAllResult.Result] = results.map { 
    case r: CreateResult.Conflict :: tail if conf.isEmpty =&gt; 
         trf(tail, Some(CreateAllResult.Conflict(r)), nt, f, Nil)
    case r: CreateResult.NotFound :: tail if nf.isEmpty  =&gt; 
         trf(tail, conf, Some(CreateAllResult.NotFound(r)), f, Nil)
    case r: CreateResult.Failed  if f.isEmpty =&gt; 
         trf(tail, conf, nf, Some(CreateAllResult.Failed(r)), Nil)
    case Ok(defn) :: tail if conf ++ nf ++ f isEmpty =&gt; 
         trf(tail, None, None, None, dfn :: defs)
    case _ if defs.isEmpty =&gt; conf ++ nf ++ f
    case _ =&gt;  CreateAllResult.Ok(defs.reverse)
  }


Oh, wait you are only returning the first failure, are you? I didn't realize that at first, thought you wanted the first of each type. 
Well, that makes it kinda simpler ... 
How about this: 

object Failure {
   def unapply(res: Result) = res match {
    case r: CreateResult.Conflict  =&gt; Some(CreateAllResult.Conflict(r))
    case r: CreateResult.NotFound  =&gt; Some(CreateAllResult.NotFound(r))
    case r: CreateResult.Failed =&gt; Some(CreateAllResult.Failed(r))
   } 
}

def trf(results: List[CreateResult.Result]) = results
  .collectFirst { case Failure(r) =&gt; r }
  .getOrElse(CreateAllResult.Ok(
     results.collect { case r: CreateResult.Ok =&gt; r.definition }
   ))