let table2 one two exp = 
	let rec eval exp (fir, sec)= match exp with
		| Var e -> if e = one then fir else sec
		| Not e -> not (eval e (fir, sec))
		| And (e1, e2) -> (eval e1 (fir, sec)) && (eval e2 (fir, sec))
		| Or (e1, e2) -> (eval e1 (fir, sec)) || (eval e2 (fir, sec))
	in
	List.map (fun (a,b) -> (a, b, (eval exp (a, b))) )  [(true, true); (true, false); (false, true); (false, false)];;

val table2 : string -> 'a -> bool_expr -> (bool * bool * bool) list = <fun>

# let rec eval2 a val_a b val_b = function
    | Var x -> if x = a then val_a
               else if x = b then val_b
               else failwith "The expression contains an invalid variable"
    | Not e -> not (eval2 a val_a b val_b e)
    | And(e1, e2) -> eval2 a val_a b val_b e1 && eval2 a val_a b val_b e2
    | Or(e1, e2) -> eval2 a val_a b val_b e1 || eval2 a val_a b val_b e2
  let table2 a b expr =
    [(true,  true,  eval2 a true  b true  expr);
     (true,  false, eval2 a true  b false expr);
     (false, true,  eval2 a false b true  expr);
     (false, false, eval2 a false b false expr)];;
val eval2 : string -> bool -> string -> bool -> bool_expr -> bool = <fun>
val table2 : string -> string -> bool_expr -> (bool * bool * bool) list =
  <fun>

let table vars exp= let module VarTable = Map.Make(String) in
	let rec get_input l before= match l with
		| [] -> [before]
		| h::t -> (get_input t ((h, true)::before)) @ (get_input t ((h, false)::before))
	in
	let rec into_map l m= match l with 
		| [] -> m
		| (name, value)::t -> into_map t (VarTable.add name value m)
	in
	let var_maps = List.map (fun e -> into_map e VarTable.empty) (get_input vars []) in 

	let rec eval inner_exp var_map= match inner_exp with
		| Var e -> VarTable.find e var_map
		| Not e -> not (eval e var_map)
		| And (e1, e2) -> (eval e1 var_map) && (eval e2 var_map)
		| Or (e1, e2) -> (eval e1 var_map) || (eval e2 var_map)
	in
	List.map (fun m -> ((VarTable.fold (fun k v acc-> acc@ [(k,v)]) m []), (eval exp m))) var_maps;;

val table :
  String.t list -> bool_expr -> ((String.t * bool) list * bool) list = <fun>

# (* [val_vars] is an associative list containing the truth value of
     each variable.  For efficiency, a Map or a Hashtlb should be
     preferred. *)

  let rec eval val_vars = function
    | Var x -> List.assoc x val_vars
    | Not e -> not (eval val_vars e)
    | And(e1, e2) -> eval val_vars e1 && eval val_vars e2
    | Or(e1, e2) -> eval val_vars e1 || eval val_vars e2

  (* Again, this is an easy and short implementation rather than an
     efficient one. *)
  let rec table_make val_vars vars expr =
    match vars with
    | [] -> [(List.rev val_vars, eval val_vars expr)]
    | v :: tl ->
         table_make ((v, true) :: val_vars) tl expr
       @ table_make ((v, false) :: val_vars) tl expr

  let table vars expr = table_make [] vars expr;;
val eval : (string * bool) list -> bool_expr -> bool = <fun>
val table_make :
  (string * bool) list ->
  string list -> bool_expr -> ((string * bool) list * bool) list = <fun>
val table : string list -> bool_expr -> ((string * bool) list * bool) list =
  <fun>

let gray n = 
	let rec init_it remain = if remain>0 then "0"::init (remain-1) else [] in
	let init = init_it n in
	let pow a b = int_of_float ((float_of_int a) ** (float_of_int b)) in
	let total = pow 2 n -1 in
	let rec next step now acc = 
		if total = List.length acc then acc
		else if step = 1 then
			match now with 
				| [] ->raise Not_found
				| h::t -> let next_step = ((if h="1" then "0" else "1") :: t) in
					next 2 next_step (next_step::acc)
			else if step = 2 then 
				let rec step_two l= match l with
					| f::s::t -> if f = "1" then (f::(if s="1" then "0" else "1")::t) 
						else (f::(step_two (s::t)))
					| _ -> raise Not_found
				in
				let next_step = step_two now in
				next 1 next_step (next_step::acc)
			else raise Not_found
	in
	List.map (fun e -> List.fold_right (fun a acc-> acc^a) e "") (init :: List.rev (next 1 init []));;

val gray : int -> string list = <fun>

# let gray n =
    let rec gray_next_level k l =
      if k < n then
        (* This is the core part of the Gray code construction.
         * first_half is reversed and has a "0" attached to every element.
         * Second part is reversed (it must be reversed for correct gray code).
         * Every element has "1" attached to the front.*)
        let (first_half,second_half) =
          List.fold_left (fun (acc1,acc2) x ->
              (("0" ^ x) :: acc1, ("1" ^ x) :: acc2)) ([], []) l
        in
        (* List.rev_append turns first_half around and attaches it to second_half.
         * The result is the modified first_half in correct order attached to
         * the second_half modified in reversed order.*)
        gray_next_level (k + 1) (List.rev_append first_half second_half)
      else l
    in
      gray_next_level 1 ["0"; "1"];;
val gray : int -> string list = <fun>

    type 'a tree_node = 
            | Nil
            | Tree_node of 'a * 'a tree_node * 'a tree_node;;

    type 'a tree_node = Nil | Tree_node of 'a * 'a tree_node * 'a tree_node

let huffman l = 
        let init_nodes = List.map (fun (name,fre) -> Tree_node ((name,fre), Nil, Nil) ) l in
        let extract_value node = match node with
            | Nil -> raise Not_found
            | Tree_node ((name,fre),l,r) -> fre
        in
        let extract_all node = match node with
            | Nil -> raise Not_found
            | Tree_node ((name,fre),l,r) -> ((name,fre),l,r)
        in
        let rec stack nodes = 
        	let sorted_nodes = List.sort (fun a b -> (extract_value a) - (extract_value b)) nodes in
                match sorted_nodes with
                	| [] -> raise Not_found
                	| f::s::t -> stack ((Tree_node (("", (extract_value f) + (extract_value s)), f, s))::t)
                	| h::t -> h
        in
        let rec assign node bits = 
        	let ((name,fre),l,r) = extract_all node in if name != "" then [(name, bits)] else (assign l (bits^"0")) @ (assign r (bits^"1"))
        in
        match (stack init_nodes) with
        	| root -> assign root ""
        	| _ -> raise Not_found;;

Line 23, characters 11-12:
Warning 11 [redundant-case]: this match case is unused.

val huffman : (string * int) list -> (string * string) list = <fun>

# (* Simple priority queue where the priorities are integers 0..100.
     The node with the lowest probability comes first. *)
  module Pq = struct
    type 'a t = {data: 'a list array; mutable first: int}
    let make() = {data = Array.make 101 []; first = 101}
        let add q p x =
      q.data.(p) <- x :: q.data.(p);  q.first <- min p q.first
          let get_min q =
      if q.first = 101 then None else
        match q.data.(q.first) with
        | [] -> assert false
        | x :: tl ->
           let p = q.first in
           q.data.(q.first) <- tl;
           while q.first < 101 && q.data.(q.first) = [] do
             q.first <- q.first + 1
           done;
           Some(p, x)
  end
    type tree =
    | Leaf of string
    | Node of tree * tree
      let rec huffman_tree q =
    match Pq.get_min q, Pq.get_min q with
    | Some(p1, t1), Some(p2, t2) -> Pq.add q (p1 + p2) (Node(t1, t2));
                                    huffman_tree q
    | Some(_, t), None | None, Some(_, t) -> t
    | None, None -> assert false
      (* Build the prefix-free binary code from the tree *)
  let rec prefixes_of_tree prefix = function
    | Leaf s -> [(s, prefix)]
    | Node(t0, t1) ->  prefixes_of_tree (prefix ^ "0") t0
                     @ prefixes_of_tree (prefix ^ "1") t1
                       let huffman fs =
    if List.fold_left (fun s (_, p) -> s + p) 0 fs <> 100 then
      failwith "huffman: sum of weights must be 100";
    let q = Pq.make () in
    List.iter (fun (s, f) -> Pq.add q f (Leaf s)) fs;
    prefixes_of_tree "" (huffman_tree q);;
module Pq :
  sig
    type 'a t = { data : 'a list array; mutable first : int; }
    val make : unit -> 'a t
    val add : 'a t -> int -> 'a -> unit
    val get_min : 'a t -> (int * 'a) option
  end
type tree = Leaf of string | Node of tree * tree
val huffman_tree : tree Pq.t -> tree = <fun>
val prefixes_of_tree : string -> tree -> (string * string) list = <fun>
val huffman : (string * int) list -> (string * string) list = <fun>