问如何从scala中的val l1 = List(1,2,3,4,5,6,7)中获得结果列表结果= List(1,2，3，4，5，6，7)？

EN

def flattenOps(l1: List[Any]): List[Int] = l1 match {
  case head :: tail => head match {
    case ls: List[_] => flattenOps(ls) ::: flattenOps(tail)
    case i: Int => i :: flattenOps(tail)
  }
  case Nil => Nil
}

flattenOps(l1).distinct

type NestedList[A] = A match {
  case Int => Int | List[NestedList[Int]]
  case _ => A | List[NestedList[A]]
}

val input: NestedList[Int] = List(1,2,List(3,List(4,5,6),5,6,7))
                 
def flattenNested[A](nested: NestedList[A]): List[A] =
  nested match
    case xs: List[NestedList[A]] => xs.flatMap(flattenNested)
    case x: A => List(x)

val result: List[Int] = flattenNested(input)

println(result.distinct)

import scala.reflec.ClassTag

sealed trait ListItem[A] {
  def flattenedItems: List[A]
} 

case class SingleItem[A](value: A) extends ListItem[A] {
  def flattenedItems: List[A] = value :: Nil
}

case class NestedItems[A](values: List[ListItem[A]]) extends ListItem[A] {
  def flattenedItems: List[A] = values.flatMap(_.flattenedItems)
} 

// The above would probably take much less lines of code in Scala 3

object ListItem {
  def parse[A : ClassTag](value: Any): ListItem[A] = {
    value match {
      case single: A => SingleItem(single)
      case nested: List[Any] => NestedItems(nested.map(parse[A]))
    }
  }
}

val l = List(1, 2, List(3, List(4, 5, 6), 5, 6, 7))

val itemizedList: List[ListItem[Int]] = l.map(ListItem.parse[Int]) 
val result = itemizedList.flatMap(_.flattenedItems).distinct