Теория, лежащая в основе вызова, поделившись

Question

Поэтому я много читал о стратегиях оценки ( как их называет Википедия) после того, как объяснил, как работает Java. (Я знаю, что они не используют термин call by share, скорее, они используют "call by value, где значение является ссылкой"), но в принципе это похоже на то же самое, а также это не касается конкретно Java.)

Я нашел много объяснений того, как они ведут себя, но не много о теории каждого метода. Я вижу преимущества звонка по значению и звонка по ссылке, но звонок по совместному доступу кажется мне немного странным. В качестве примера и чтобы убедиться, что у меня есть эти прямые:

foo() {
    int[] x = [1, 2, 3];
    int[] y = [1, 2, 3];
    bar(x, y);
    print(x);
    print(y);
}

bar(a, b) {
    a = [3, 4, 5];
    b[0] = 4;
}

В строгом вызове по значению вывод foo будет [1, 2, 3] и [1, 2, 3], так как a и b внутри бара являются глубокими копиями x и y внутри foo. Ничего не поделено между ними.

При обращении по ссылке, выходные данные будут [3, 4, 5] и [4, 2, 3], так как a и b в столбце - это те же переменные, что и x и y в foo, только с псевдонимом в этой области видимости.

В вызове с помощью совместного использования выходные данные будут [1, 2, 3] и [4, 2, 3], поскольку a и b в столбце - это разные переменные, но они указывают на те же массивы, что и x и y в foo.

Логично, что как только вы знаете правила, все они имеют смысл, но колл-обмен кажется странным.

Вызов по ссылке, по крайней мере из моего опыта, кажется наиболее интуитивным, поскольку новые разработчики склонны рассматривать функции как расширения вызывающей стороны, где вызов функции будет по сути аналогичен вставке того же кода в вызывающий метод.

Вызов по значению препятствует тому, чтобы метод изменил переменную или ее содержимое без ведома вызывающей стороны, что хорошо, если другие работают с чем-то, что вы написали, но не имеете доступа к исходному коду, или даже если вы забыли, так что вы не стреляйте себе в ногу.

Звонок с помощью обмена имеет плюсы, экономит память (по сравнению со строгим звонком по значению) и не позволяет полностью выстрелить себе в ногу (по сравнению со звонком по ссылке)- вы можете сделать это только частично - но это также кажется противоречивым при просмотре на то, как это влияет на передаваемые значения / объекты, что действительно неприятно для меня лично. Очевидно, что это довольно популярный подход, поскольку он используется в Python, Java, Ruby, JavaScript и т. Д. Итак, учитывая его популярность, он, безусловно, имеет свои достоинства, и мне было интересно, в чем именно заключается эта заслуга. Это вопрос практичности, есть ли что-то большое, что я упускаю, что-то еще полностью?

Обратите внимание, я не ищу, какой метод является лучшим, так как кажется, что это вопрос личных предпочтений. Мне просто любопытно, что за идея была реализована, а также чтобы я правильно понял вещи.