// Demonstrating algebraic data types and pattern matching
//
// Expected output:
// Tree sum: 8
// Tree depth: 3
// Safe divide 10/2: Result: 5
// Safe divide 10/0: Division by zero!

// Define a binary tree
type Tree =
    | Leaf(Int)
    | Node(Tree, Tree)

// Sum all values in a tree
fn sumTree(tree: Tree): Int =
    match tree {
        Leaf(n) => n,
        Node(left, right) => sumTree(left) + sumTree(right)
    }

// Find the depth of a tree
fn depth(tree: Tree): Int =
    match tree {
        Leaf(_) => 1,
        Node(left, right) => {
            let leftDepth = depth(left)
            let rightDepth = depth(right)
            1 + (if leftDepth > rightDepth then leftDepth else rightDepth)
        }
    }

// Example tree:
//       Node
//      /    \
//    Node   Leaf(5)
//   /    \
// Leaf(1) Leaf(2)

let myTree = Node(Node(Leaf(1), Leaf(2)), Leaf(5))
let treeSum = sumTree(myTree)
let treeDepth = depth(myTree)

// Option type example
fn safeDivide(a: Int, b: Int): Option<Int> =
    if b == 0 then None
    else Some(a / b)

fn showResult(result: Option<Int>): String =
    match result {
        None => "Division by zero!",
        Some(n) => "Result: " + toString(n)
    }

// Print results
fn printResults(): Unit with {Console} = {
    Console.print("Tree sum: " + toString(treeSum))
    Console.print("Tree depth: " + toString(treeDepth))
    Console.print("Safe divide 10/2: " + showResult(safeDivide(10, 2)))
    Console.print("Safe divide 10/0: " + showResult(safeDivide(10, 0)))
}

let output = run printResults() with {}