def group :comparable

def this:T < that:T -> :boolean
    if :T is :comparable

def this:T == that:T -> :boolean
    if :T is :comparable

def this:T > that:T -> :boolean
    where :T is :comparable
    return this < that .Not.And(this == that .Not)
    
def this:T != that:T -> :boolean
    where :T is :comparable
    return this == that .Not

def this:T >= that:T -> :boolean
    where :T is :comparable
    return this > that .Or (this == that)

def this:T <= that:T -> :boolean
    where :T is :comparable
    return this < that .Or  (this == that)

def group :T:binaryTree
    where :T is :comparable

def thing :T:node 
    .value  :T
    .left   :T:binaryTree
    .right  :T:binaryTree
    
def :T:node is :T:binaryTree

def thing :emptyNode

def :emptyNode is :binaryTree

def this:T:X.Insert child:T -> :T:binaryTree
    if :X is :binaryTree 

def this:T:node.Insert child:T -> :T:binaryTree
    if this.value == child 
        return this
    if this.value < child 
        return this with 
            .left = this.left.Insert child
    if this.value > child
        return this with
            .right = this.right.Insert child
            
            
def this:emptyNode.Insert child:T -> :T:binaryTree
    return :T:node
        .value = child
        .left  = :emptyNode
        .right = :emptyNode

            
def this:T:list.ToTree -> :T:binaryTree
    return this.Foldr (_.Insert __) From :emptyNode 

def this:T:X.ToList -> :T:list
    if :X is :binaryTree

def this:emptyNode.ToList -> :T:list
    return []

def this:T:node.ToList -> :T:list
    return this.left.ToList 
        ++ [this.value] 
        ++ this.right.ToList

def this:T:X.Contains child:T -> :boolean
    if :X is :binaryTree
        
def this:emptyNode.Contains child:T -> :boolean
    return #false

def this:T:node.Contains child:T -> :boolean
    if this.value == child 
        return #true
    if this.value < child
        return this.left.Contains child
    if this.value > child
        return this.right.Contains child
    
def this:T:X.Minimum -> :T
    if :X is :binaryTree

def this:emptyNode.Minimum -> :T
    throw

def this:T:X.IsEmpty -> :boolean
    if :X is :binaryTree 

def this:emptyNode.IsEmpty -> #true
def this:T:node.IsEmpty -> #false


def this:T:node.Minimum -> :T
    if this.left.IsEmpty
        return this.value
    else 
        return this.left.Minimum

def this:T:X.Maximum -> :T
    if :X is :binaryTree

def this:emptyNode.Maximum -> :T
    throw

def this:T:node.Maximum -> :T
    if this.right.IsEmpty
        return this.value
    else
        return this.right.Maximum
        
def this:T:binaryTree.InOrder -> this.ToList

def this:T:X.PreOrder -> :T:list
    if :X is :binaryTree

def this:emptyNode.PreOrder -> :T:list
    return []

def this:T:node.PreOrder -> :T:list
    return [this.value] 
        ++ this.left.PreOrder
        ++ this.right.PreOrder

def this:T:X.PostOrder -> :T:list
    if :X is :binaryTree

def this:emptyNode.PostOrder -> :T:list
    return []

def this:T:node.PostOrder -> :T:list
    return this.left.PostOrder
        ++ this.right.PostOrder
        ++ [this.value]