fn foo1(mut arr []int) {
    for _, mut j in arr {
        j *= 2
    }
}

fn test_for_in_mut_val_of_array() {
    mut arr := [1, 2, 3]
    foo1(mut arr)
    println(arr)
    assert arr == [2, 4, 6]
}

fn foo2(mut arr [3]int) {
    for _, mut j in arr {
        j *= 2
    }
}

fn test_for_in_mut_val_of_fixed_array() {
    mut arr := [1, 2, 3]!
    foo2(mut arr)
    println(arr)
    assert arr == [2, 4, 6]!
}

fn foo3(mut m map[string][3]int) {
    for i in 0 .. m['hello'].len {
        m['hello'][i] *= 2
    }
}

fn test_fn_mut_val_of_map() {
    mut m := {
        'hello': [1, 2, 3]!
    }
    foo3(mut m)
    println(m)
    assert '${m}' == "{'hello': [2, 4, 6]}"
}

fn foo4(mut m map[string][3]int) {
    for _, mut j in m['hello'] {
        j *= 2
    }
}

fn test_for_in_mut_val_of_map() {
    mut m := {
        'hello': [1, 2, 3]!
    }
    foo4(mut m)
    println(m)
    assert '${m}' == "{'hello': [2, 4, 6]}"
}

fn test_for_in_mut_val_of_map_direct() {
    mut m := {
        'foo': 1
        'bar': 2
    }
    for _, mut j in m {
        j = 3
    }
    println(m)
    assert '${m}' == "{'foo': 3, 'bar': 3}"
}

fn test_for_in_mut_val_of_map_fixed_array() {
    mut m := {
        'foo': [{
            'a': 1
        }]!
        'bar': [{
            'b': 2
        }]!
    }
    for _, mut j in m {
        j = [{
            'c': 3
        }]!
    }
    println(m)
    assert '${m}' == "{'foo': [{'c': 3}], 'bar': [{'c': 3}]}"
}

fn test_for_in_mut_val_of_string() {
    b := 'c'
    mut c := ['a', 'b']
    mut ret := []string{}
    for mut a in c {
        a = a + b
        ret << a
    }
    println(ret)
    assert ret == ['ac', 'bc']
}

fn test_for_in_mut_val_of_float() {
    mut values := [1.0, 2, 3]
    println(values)

    for mut v in values {
        v = 1.0
        v = v + 1.0
    }
    println(values)
    assert values == [2.0, 2, 2]
}