spławik 10

//zadanie 1
class GenericCellMut[+T] (var x: T) {
}
//a)
//Modyfikowalne strutury powinny być inwariantne
//Bo mając GenericCellMut[Int] mógłbym traktować ją jako
//GenericCellMut[Any] bo Int <: Any ale wtedy mógłbym równie dobrze
//Dać tam String bo String <: Any.
//b)
//Albo robimy to inwariantne albo struktura zostaje niemodyfikowalna

//zadanie 2
abstract class Sequence[+A] {
  def append[B >: A](x: Sequence[B]):Sequence[A] //zapewniamy, że A jest podtypem B i w tej funkcji zawsze bezpiecznie możemy użyć A w kontekście B
}

trait Function1[-T1, +R] {  //kontrawariantość argumentów i kowariantość wyników
  def apply(t : T1) : R
  ...
}
//Scala definuje trait Function1 jako posiadającą dwa parametry typu
//Function1[GParent,Child] <: Function1[Parent,Parent]
//W naszej funkcji powiedzieliśmy że T jest kowariwantne i że bierze parametr x typu T
//Więc w pewnym momencie możemy mieć jakieś S <: T i wtedy instancję GenericCellMut[T]
//Moglibyśmy zastąpić GenericCellMut[S] ale wtedy wszystkie metody biorące T nie mogÄ
//być zastąpione przez S bo to co wyżej

//zadanie 3
class Queue[T] private (val l1: List[T], val l2: List[T]) {
  class EmptyException(message: String) extends Exception(message)

  def this() = this(Nil, Nil)

  def enqueue(elem: T) = {
    (l1, l2) match {
      case (Nil, Nil) => new Queue(List(elem), Nil)
      case (lt1, lt2) => new Queue(l1, elem :: l2)
    }
  }

  def dequeue() = {
    (l1, l2) match {
      case (Nil, Nil) => this
      case (List(_), l) => new Queue(l.reverse, Nil)
      case (_ :: t, l) => new Queue(t, l)
    }
  }

  def first() =
    (l1, l2) match {
      case (Nil, Nil) => throw new EmptyException("Kolejka jest pusta!")
      case (h :: _, _) => h
      case _ => throw new EmptyException("B³šd implementacji!")
    }

  def isEmpty = l1 == Nil
}

//zadanie 4
import scala.collection.mutable._
def copy[T](dest: Seq[T], src: Seq[T]): = { // reprezentuje ciągi - kolekcje o określonym porządku.
  var i = 0
  src foreach {
    el =>
      dest.update(i, el) //update zwraca kopie seq ze zmienionym jedynym elementem
      i += 1
  }
 }
 val a = Seq(1,2,3)
 val b = Seq(3,3,3,4,5)
 copy(b,a)
 b.toString //res2: String = ArrayBuffer(1, 2, 3, 4, 5)