struct Matrix[T] {
    row int
    col int
mut:
    data [][]T
}

fn from_array[T](arr [][]T) Matrix[T] {
    return Matrix[T]{
        row:  arr.len
        col:  arr[0].len
        data: arr.clone()
    }
}

fn (m1 Matrix[T]) + (m2 Matrix[T]) Matrix[T] {
    if m1.row != m2.row || m1.col != m2.col {
        panic('Addition can only be performed on matrix with same size')
    }
    mut res := Matrix[T]{
        row:  m1.row
        col:  m1.col
        data: m1.data.clone()
    }
    for i in 0 .. m2.row {
        for j in 0 .. m2.col {
            res.data[i][j] += m2.data[i][j]
        }
    }
    return res
}

fn (m1 Matrix[T]) == (m2 Matrix[T]) bool {
    return m1.row == m2.row && m1.col == m2.col && m1.data == m2.data
}

fn (m1 Matrix[T]) < (m2 Matrix[T]) bool {
    return m1.row < m2.row && m1.col < m2.col
}

fn test_generic_operator_overload() {
    mut a1 := from_array([[1, 2, 3], [4, 5, 6]])
    a2 := from_array([[7, 8, 9], [10, 11, 12]])

    plus_ret := a1 + a2
    println(plus_ret)
    assert plus_ret.row == 2
    assert plus_ret.col == 3
    assert plus_ret.data == [[8, 10, 12], [14, 16, 18]]

    a1 += a2
    println(a1)
    assert a1.row == 2
    assert a1.col == 3
    assert a1.data == [[8, 10, 12], [14, 16, 18]]

    eq_ret := a1 == a2
    println(eq_ret)
    assert !eq_ret

    ne_ret := a1 != a2
    println(ne_ret)
    assert ne_ret

    lt_ret := a1 < a2
    println(lt_ret)
    assert !lt_ret

    le_ret := a1 <= a2
    println(le_ret)
    assert le_ret

    gt_ret := a1 > a2
    println(gt_ret)
    assert !gt_ret

    ge_ret := a1 >= a2
    println(ge_ret)
    assert ge_ret
}