OCaml中的二叉搜索树插入功能

Question

Suppose we want to insert value smaller. It will go to Node (insert x left, k, right) I don't understand how we can have insert x left when function insert is declared as taking only one argument, the key. How can left also be passed to insert funtion?

type 'a bst_t =  
| Leaf
| Node of 'a bst_t * 'a * 'a bst_t

let rec insert x = function  
  | Leaf -> Node (Leaf, x, Leaf) 
  | Node (left, k, right) ->
    if x < k then Node (insert x left, k, right) 
    else Node (left, k, insert x right) 

Answer 1

Ocaml has a REPL, ie an interactive environment useful for experimenting and having a conversation with ocaml .

$ ocaml
        OCaml version 4.02.3

# type 'a bst_t =
| Leaf
| Node of 'a bst_t * 'a * 'a bst_t    ;;
type 'a bst_t = Leaf | Node of 'a bst_t * 'a * 'a bst_t
# let rec insert x = function
  | Leaf -> Node (Leaf, x, Leaf)
  | Node (left, k, right) ->
    if x < k then Node (insert x left, k, right)
    else Node (left, k, insert x right)         ;;
val insert : 'a -> 'a bst_t -> 'a bst_t = <fun>

The read-eval-print-loop shows not only the value of the evaluated expression but also its type. Here, you can see that the symbol insert is bound to a function which takes a value of "some type 'a " and returns another function that takes a value of "a binary tree of that type 'a " and returns a value of the same binary tree of 'a type.

I strongly recommend to use REPLs whenever you have them, as they tell you a lot about the system.

Answer 2

The function keyword defines a function as a series of patterns, and is almost always used without giving the parameter a name as such. So the insert function actually has two parameters.

This definition without function is equivalent:

let rec insert x node =
  match node with
  | Leaf -> Node (Leaf, x, Leaf) 
  | Node (left, k, right) ->
    if x < k then Node (insert x left, k, right) 
    else Node (left, k, insert x right) 

Answer 3

Although it might seem so at first sight, function insert has not one but two arguments - one is the key to be inserted as you said, and the second one is the bst_t in which you want to insert the key.

In OCaml, the concept of Point-free programming is highly recommended when it's possible to apply it, and that's precisely what happens with your insert function. Your version of the function is just a short-hand notation for the following function (written in normal, verbose syntax):

let rec insert x bst = match bst with 
| Leaf -> Node (Leaf, x, Leaf) 
| Node (left, k, right) ->
  if x < k then Node (insert x left, k, right) 
  else Node (left, k, insert x right) 

where bst is the tree on which the insertion is performed, ie the tree that the function matches the Leaf | Node Leaf | Node patterns against.