type 'a llist = LNil | LCons of 'a * (unit -> 'a llist) (*tutaj deklarujemy(czy to dobre słowo?) typ i bez tego ani rusz *)

(*lfrom generuje ciąg rosnących liczb całkowitych zaczynający się od k.*)
# let rec lfrom k = LCons (k, function () -> lfrom (k+1));;
val lfrom : int -> int llist = <fun>

(*ltake(n,xl) zwraca pierwszych n elementów listy leniwej xl w postaci zwykłej
listy*)
# let rec ltake = function
(0, _) -> []
| (_, LNil) -> []
| (n, LCons(x,xf)) -> x::ltake(n-1, xf())
;;
val ltake : int * 'a llist -> 'a list = <fun>

(* toLazyList ze zwykłej listy tworzy listę leniwą*)
#let rec toLazyList = function
[] -> LNil
| h::t -> LCons(h, function () -> toLazyList t);;
val : toLazyList: 'a list -> 'a llist


(*zad 1*)
let l1 = [1;2;3;4;5];;

let rec replicateElements (k, list) =
    let rec replicate = function
        | (_, LNil) -> LNil
        | (n, LCons(h, xf)) ->
            if n = 0 then replicate(k, xf())
            else
            if (n>0) then LCons(h, fun () -> replicate (n - 1 ,LCons(h,xf))) else failwith "ujemny argument"
    in replicate(k, list);;

val replicateElements : int * a'list -> a' llist = <fun>

let l2 = toLazyList l1;;
ltake(5,l2);;
let l3 = replicateElements(2, l2);;
ltake(10,l3);;

(*zad 2*)
let lfib =
    let rec fib (number, acc) =
        LCons(number, fun () -> fib(acc, number + acc))
    in fib(0, 1);;
val lfib : int llist = LCons(0, fun)

ltake(10,lfib);;


(*wywołanie*)
type 'a llist = LNil | LCons of 'a * (unit -> 'a llist)

let rec ltake = function
(0, _) -> []
| (_, LNil) -> []
| (n, LCons(x,xf)) -> x::ltake(n-1, xf())

let rec toLazyList = function
[] -> LNil
| h::t -> LCons(h, function () -> toLazyList t);;

let lfib =
    let rec fib (number, acc) =
        LCons(number, fun () -> fib(acc, number + acc))
    in fib(0, 1);;

let l1 =[1;2;3;4;5];;
let l2 = toLazyList l1;;
ltake(5,l2);;
lfib l2;;