interface Widget {
}

interface ResizableWidget {
    Widget
    resize(x int, y int) int
}

fn draw(w Widget) {
    // w.resize(10, 20) // <- this won't work, since all Widgets may not implement resize()

    // however, we can check if the underlying type of w implements a different interface:
    if w is ResizableWidget {
        assert w is WidgetB
        rw := w as ResizableWidget
        assert rw is WidgetB
        // if so, we can now safely call that extra method
        assert rw.resize(10, 20) == 200
    } else {
        assert w is WidgetA
    }
}

fn draw_ref(w &Widget) {
    if w is ResizableWidget {
        rw := w as ResizableWidget
        assert rw.resize(10, 20) == 200
    } else {
        assert false
    }
}

// implements Widget, but not ResizableWidget
struct WidgetA {
}

// implements both Widget and ResizableWidget
struct WidgetB {
}

fn (w WidgetB) resize(x int, y int) int {
    return x * y
}

fn test_interface_runtime_conversions() {
    draw(WidgetA{})
    draw(WidgetB{})
}

enum CompositeNodeType {
    int
    str
    list
    block
}

interface CompositeValue {
    type_of() CompositeNodeType
}

interface CompositeNode {
    values []CompositeValue
}

type CompositeInt = int

fn (x CompositeInt) type_of() CompositeNodeType {
    return .int
}

type CompositeStr = string

fn (x CompositeStr) type_of() CompositeNodeType {
    return .str
}

struct CompositeList {
    values []CompositeValue
}

fn (x CompositeList) type_of() CompositeNodeType {
    return .list
}

struct CompositeBlock {
    values []CompositeValue
}

fn (x CompositeBlock) type_of() CompositeNodeType {
    return .block
}

fn composite_values_identical(v1 CompositeValue, v2 CompositeValue) bool {
    if v1.type_of() != v2.type_of() {
        return false
    }
    return match v1 {
        CompositeInt { v1 == (v2 as CompositeInt) }
        CompositeStr { v1 == (v2 as CompositeStr) }
        CompositeList, CompositeBlock { composite_nodes_identical(v1, v2 as CompositeNode) }
        else { false }
    }
}

fn composite_nodes_identical(s1 CompositeNode, s2 CompositeNode) bool {
    if s1.values.len != s2.values.len {
        return false
    }
    for i := 0; i < s1.values.len; i++ {
        if !composite_values_identical(s1.values[i], s2.values[i]) {
            return false
        }
    }
    return true
}

fn test_interface_runtime_conversions_from_aggregate_smartcast_to_interface() {
    list1 := CompositeList{
        values: [CompositeValue(CompositeInt(34)), CompositeStr('foo')]
    }
    list2 := CompositeList{
        values: [CompositeValue(CompositeInt(34)), CompositeStr('bar')]
    }
    block1 := CompositeBlock{
        values: [CompositeValue(CompositeInt(34)), CompositeStr('foo')]
    }
    block2 := CompositeBlock{
        values: [CompositeValue(CompositeInt(34)), CompositeStr('foo')]
    }
    assert !composite_values_identical(list1, list2)
    assert composite_values_identical(block1, block2)
}