object Pierwsze extends App{

//przykladowe definicje funkcji skladowych
def f(a:Int):Int={
    a*2
}
def g(b:Int):Int={
    b*b
}
def op(a:Int,b:Int):Int={
   a+b
}

def compose[A,B,C](f: A => B)(g: B => C) : A => C ={
    x:A => g(f(x))
}

def prod[A,B,C,D](f: A => C, g: B => D): (A, B) => (C, D) ={
   (x:A, y:B) => (f(x), g(y))
}

def lift[A,T](op: (T,T) => T)(f: A => T, g: A => T): A => T = {
      (a: A) => op(f(a), g(a))
}

//przykladowe wywolania

print(compose(f)(g)(5)+"\n")
//100 bo g(f(5))=g(5*2)=g(10)=10*10
print(prod(f,g)(4,5)+"\n")
//(8,25) bo (f(4),g(5))=(4*2,5*5)
print(lift(op)(f,g)(5))
//35 bo op((f(5),g(5)))=op(5*2,5*5)=op(10,25)=10+25
}



object Czwarte extends App{

    //ogonowa
    def size[A](a:Seq[A]):Int={
         def sizeAcc[A](a: Seq[A], length :Int): Int={
            if(a.isEmpty) length
            else sizeAcc(a.tail,length+1)
        }
        sizeAcc(a,0)
    }

    //zwykla
    def sizeZwykla[A](a:Seq[A]):Int={
        if(a.isEmpty) 1
        else 1+size(a.tail)
    }


    print(size(Seq(1,2,3)))
    print(sizeZwykla(Seq(1,2,3,4)))



}