how to copy const struct with indirections to mutable one (of the same type)

[drug via Digitalmars-d-learn]

I had the following code:
```
import std.algorithm: equal;
struct Data
{
        int[3] arr;
}

int main()
{
        auto const_data = const(Data)([1, 2, 3]);
        assert(const_data.arr[].equal([1, 2, 3]));
                
        Data mutable_data = const_data;
        assert(mutable_data.arr[].equal([1, 2, 3]));
                
        return 0;
}
```
It workred fine. Now I replace static array by std.container.Array:
```
import std.algorithm: copy, equal;
import std.container: Array;

struct Data
{
        Array!int arr;
        
        this(R)(R r)
        {
                r.copy(arr[]);
        }

    ref Data opAssign(const(Data) other)
    {
        pragma(msg, __FUNCTION__);

        import std.range: lockstep;

        this.arr.length = other.arr.length;
        foreach(ref s, ref d; lockstep(other.arr[], this.arr[]))
            d = s;

        return this;
    }
}

int main()
{
        auto const_data = const(Data)([1, 2, 3]);
        assert(const_data.arr[].equal([1, 2, 3]));
                
        Data mutable_data = const_data;
        assert(mutable_data.arr[].equal([1, 2, 3]));
                
        return 0;
}
```

and it fails now because:
``
Error: conversion error from const(Data) to Data
```
I can solve my problem in other ways but I'd like to know why opAssign 
overload doesn't work in this case?

Thank in advance