BST使用模块-OCaml

Question

I am trying to create module/interface (i dont exactly know how its called, i am new to the language) for basic operations on BST in OCaml. My goal is to have an implementation that lets me doing something like this:

T.create();;
T.push(2);;
T.push(3);;
T.push(5);;

in order to get a bst tree consisting of 2,3,5.

But at the moment to achieve this i have to write something like this:

 let teeBst = T.push(2)(T.push(3)(T.push(5)(T.create())));;

So when I am checking/using my code I have to do it like this:

    let tee2 = T.push(2)(T.push(3)(T.push(5)(T.create())));;
    T.postorder(tee2);;

The output is fine:

 # val tee2 : T.bt = <abstr>
 # - : int list = [2; 3; 5]

But, as I said before, I would like to achieve this doing as below:

T.push(2);;
T.push(3);;
T.push(5);;
T.postorder();;

(I realise this requires some changes to my postorder function but the one I am currently using is a temporary one so I can check the tree I have atm )

Below is my implementation. If you see the solution, please let me know ;)

   module type Tree =
    sig
        type bt
        val create: unit -> bt
        val push: int -> bt -> bt
        val find: int -> bt -> bool
        val preorder: bt -> int list
        val postorder: bt -> int list
        val inorder: bt -> int list
    end;;

module T : Tree =
    struct
        type bt = E | B of bt * int * bt
        let create () = E
        let rec push x = function
            | E -> B(E, x, E)
            | B (l, y, r) when x<y -> B(push x l, y, r)
            | B (l, y, r) when x>y -> B(l, y, push x r)
            | xs -> xs;;

        let rec find x = function
            | E -> false
            | B(l, y,_) when x< y -> find x l
            | B(_,y,r) when x>y -> find x r
            | _ -> true;;

        let rec preorder = function
            | B(l,v,r) -> v::(preorder r) @ (preorder l)
            | E -> [];;

        let rec inorder = function
            | B(l,v,r) ->(inorder r) @ v::(inorder l)
            | E -> []


        let rec postorder = function
            | B(l,v,r) -> (postorder r) @ (postorder l) @ [v]
            | E -> []
    end;;

Answer 1

It seems like you want modules to be classes, but I'd advise you to consider more idiomatic solutions. Have you considered using the pipe operator?

T.create()
|> T.push(2)
|> T.push(3)
|> T.push(5)
|> T.postorder;;

Or with local open (which makes more sense if you have a module with a longer name than just T of course) you can even do

T.(
  create()
  |> push(2)
  |> push(3)
  |> push(5)
  |> postorder
);

What you're asking for would require introducing global mutable state, which isn't just "some changes" but an entirely different paradigm. And one that is generally frowned upon because it makes your code unpredictable and hard to debug since it relies on state that might change at any moment from anywhere.

Another possibility is to actually use classes, since OCaml has those too. Then you'd still have mutable state, but it would at least be contained.