takeEqual :: Int -> [Int] -> [Int]
takeEqual _ [] = []
takeEqual n (x:xs) | n == x = x : takeEqual n xs
                   | otherwise = []
                     
groupEquals :: [Int] -> [[Int]]
groupEquals [] = []
groupEquals (x:xs) = takeEqual x xs : groupEquals xs

groupEquals (x:xs) = (x : takeEqual x xs) : groupEquals xs

  def pack[A](l: List[A]): List[List[A]] = {
    def R(f: List[A], l: List[A]): List[List[A]] = (f, l) match {
      case (ys, Nil) => ys :: Nil
      case (Nil, x :: xs) => R(List(x), xs)
      case (y :: ys, x :: xs) => if (x == y) R(x :: y :: ys, xs)
                                 else (y :: ys) :: R(List(x), xs)
    }

    R(Nil, l)
  }

type Tupel = (Int, Int)

myZip :: [Int] -> [Int] -> [Tupel]
myZip (x:xs) (y:ys) = (x,y) : myZip xs ys

myUnzip :: [Tupel] -> [Int] -> [Int]
myUnzip ((x,y):(xs,ys)) = [] []

  def pack2[A](l: List[A]): List[List[A]] = {
    def take(pred: A => Boolean, l: List[A] ): (List[A], List[A]) = l match {
      case Nil => (Nil, Nil)
      case (x :: xs) => if (pred(x)) {
                          take(pred, xs) match {
                            case (y, z) => (x :: y, z)
                          }
                        }
                        else (Nil, x :: xs)
    }

    if (l.isEmpty) Nil
    else {
      val (p, n) = take (_ == l.head, l)
      if (n.isEmpty)  List(p)
      else            p :: pack2(n)
    }
  }