//1
type boolex = Const of bool | Var of char | And of boolex * boolex | Neg of boolex;;

type environment = char list;;

let rec eval exp env=
    match exp with
    |Const b -> b
    |Var c -> List.exists (fun x->x=c) env
    |And (b1,b2)->
        if eval b1 env && eval b2 env
        then true
        else false
    |Neg b->
        if eval b env
        then false
        else true


let env1 = ['b'; 'c'];;
let env2 =['c'] ;;

let b1 = And(Var 'b',Var 'c');;
let b2 = And(Neg b1, Const (3+5 = 8));;

eval b1 env1;;
eval b1 env2;;
eval b2 env1;;
eval b2 env2;;

//2
//type enviroment = Map<char,bool>;;
type ifex = Bool of bool | V of char | If of ifex * ifex * ifex

//let if_env1 = Map.add 'x' true (Map.add 'y' false Map.empty);
//let if_env2 = Map.add 'x' false (Map.add 'y' true Map.empty);

//3
let rec ifeval exp env =
    match exp with
    |Bool b -> b
    |V s -> List.exists (fun x->x=s) env
    |If (c,v,f) ->
        if (ifeval c env)
        then ifeval v env
        else ifeval f env

let env3 =['x'] ;;

let prova_1 = ifeval (If(Bool (3 = 4), Bool (1<2), If(Bool true, V 'x' , V 'y'))) env1
let prova_2 = ifeval (If(Bool (3 = 4), Bool (1<2), If(Bool true, V 'x' , V 'y'))) env2
let prova_3 = ifeval (If(Bool (3 = 4), Bool (1<2), If(Bool true, V 'x' , V 'y'))) env3

//4
let rec bool2if bx=
    match bx with
    |Const b -> Bool b
    |Var c -> V c
    |And (a,b)->If(bool2if a,bool2if b,Bool false)
    |Neg a -> If(bool2if a, Bool false, Bool true)

let try_conversion = And( Neg(Const true),Const true);;
let conversione = bool2if try_conversion;; // if( if(true,false,true), true, false )

//5
#r @"C:\Users\ceffa\Documents\Visual Studio 2013\Projects\packages\FsCheck.1.0.4\lib\net45\FsCheck.dll";;
open FsCheck

let prop bx env=
    ifeval (bool2if bx) env = eval bx env

Check.Quick prop;


//ESERICZIO 2

//funzioncina per stampare inizio delle liste
let printseq s n = Seq.take n s |> Seq.toList ;;

let nat = Seq.initInfinite (fun x -> x);;
let seq1 = seq{
    yield 0 ;
    yield 1 ;
    yield 2 ;
    yield 0 ;
    yield 3 ;
    yield 4 ;
    yield 4 ;
    yield 3 ;
    yield 1 ;
    yield! Seq.initInfinite (fun x -> x+5)
    }

let seq2 = Seq.initInfinite (fun x ->  (x/2));;

let seq3 =
    let rec add_chunk n =
        seq{
            for i in 0..n do yield i;
            yield! add_chunk (n+1)
        }
    add_chunk 0;

printseq nat 20;;
printseq seq1 20;;
printseq seq2 20;;
printseq seq3 20;;

let rec is_in_list ls n=
    match ls with
    |[]->false
    |x::xs->if (x=n) then true else is_in_list xs n

let add_to_list ls n =
    if (is_in_list ls n = false) then n::ls else ls

let rec auxiliary_distinct sq ls=
    let first = Seq.nth 0 sq
    let tail = Seq.skip 1 sq
    seq{
        if is_in_list ls first = false then yield first;
        yield! auxiliary_distinct tail (add_to_list ls first)
    }

let distinct sq =
    auxiliary_distinct sq []

printseq (distinct nat) 20;;//tutti e 4 uguali
printseq (distinct seq1) 20;;
printseq (distinct seq2) 20;;
printseq (distinct seq3) 20;;

[1;2;3;4] = [1;2;3;4]

let isEqual sq1 sq2 n=
    (Seq.take n sq1 |> Seq.toList) = (Seq.take n sq2 |> Seq.toList)

isEqual nat seq1 20;; //false
isEqual (distinct nat) (distinct seq2) 20;; //true
isEqual nat (distinct seq1) 20;;//true
isEqual nat (distinct seq2) 20 ;;//true
isEqual nat (distinct seq3) 20;;//true

#r "cset"
open FSet
let f1 = FSet.empty;;
FSet.contains 3 f1;;
let f2 = FSet.singleton 3;
FSet.contains 3 f2;;
let f3 = FSet.add 4 f1;;
let f4 = FSet.union f3 f1;
FSet.contains 4 f3;;
FSet.contains 4 f4;;
let f5 = FSet.ofList [2;4;7;99;100;1000; 11];;
FSet.contains 4 f5;;
FSet.contains 99 f5;;
FSet.contains 900 f5;;
FSet.contains 11 f5;;

#r @"C:\Users\ceffa\Documents\Visual Studio 2013\Projects\packages\FsCheck.1.0.4\lib\net45\FsCheck.dll";;
open FsCheck


let prop_fset n (set : int list)=
    Set.contains n (Set.ofList set) = FSet.contains n (FSet.ofList set)


Check.Quick prop_fset;;