Вопрос по call by value

связываем значение a (1) с идентификатором x

т.е. копируем значение 1 в новый слот и связываем его с x.

guile> (define (tst x) (write x) (set! x b) (write x))
guile> (define a 1)                                   
guile> (define b 2)
guile> (tst a)
12
guile> a
1
guile> b
2

Т.е. изменение x не влияют на a - x содержит копию значения a.

тебе объяснили как «связывание» работает «под капотом». что не так?

Лизни уже розетку от электроплиты, чмо нулевое.

т.е. копируем значение 1 в новый слот и связываем его с x.

что значит копируем? у тебя что идентификатор, что 1 в единственном экземпляре в программе находятся. Это линкование а не копирование.

Т.е. изменение x не влияют на a - x содержит копию значения a.

Конечно не влияют, ведь мы не тронаем связку а -> 1. Копирование тут не при чем.

тебе объяснили как «связывание» работает «под капотом». что не так?

Не так то, что не может оно так работать. Есть подозрение, что пишущий соврал:)

ведь мы не тронаем связку а -> 1

Без копирования:

a --+-> 1
x --|

Копирование:

a -> 1
x -> 1 (копия, создаваемая при входе в функцию)

Копирование:

Если следовать этой логике, то

a=1
b=a

Зависит от языка. В схемке значение копируется. Возможно используется CoW, но это уже детали.

guile> (define a 1)
guile> (define b a)
guile> (set! b 2)
guile> a
1
guile> b
2

это тоже *копирование*.

Всё копирование, кроме алиасинга, когда 2 переменные указывают на один слот и можно значение изменять через любую из них. Так работает жабка, например, или ссылки в крестах.

значение копируется

Ты можешь дать определение, что ты подразумеваешь под понятием «копирование»?

что ты подразумеваешь под понятием «копирование»?

Создается новый слот, значение из старого слота копируется в новый.

Всё копирование, кроме алиасинга, когда 2 переменные указывают на один слот

Но в этом примере так оно и есть, у тебя 2 переменные указывают н одно и то же значение.

Создается новый слот, значение из старого слота копируется в новый.

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

который указывает на уже существующее значение

Слот никуда не указывает, он _содержит_ значение. Переменная указывает на слот.

2 переменные указывают н одно и то же значение

Они указывают на разные слоты, но слоты имеют одинаковое значение, т.к. значение было скопировано.

Да, но есть разница между

slot1: <slot-name> - <the-value>
slot2: <slot-name> - <the-value>

где оба имени ссылаются на одно и то же значение

и

slot1: <slot-name> - <the-value>
slot2: <slot-name> - <copy-the-value>

где имена ссылаются на разные значения.

[/copy]

В первом случае никаких копий нет, у тебя только одно the-value. Какое это отношение имеет к копированию? У тебя оба идентификатора ссылаются на одно и то же. То что это разные слоты, никто не спорит, но копирование то тут причем?

анонiмус, ты?

Они указывают на разные слоты, но слоты имеют одинаковое значение, т.к. значение было скопировано.

они не указывают на разные слоты, они сами являются именами слотов. Это просто сахар, на JS это можно записать

global.a=1
global.b=global.a

у тебя только одно the-value

Это у тебя одно, а у меня два одинаковых значения в двух разных слотах.

а у меня два одинаковых значения в двух разных слотах.

Да. Это то же самое, что и я говорю. Там нет никаких копий. создание слота и линковка знчения никакого отношения к копированию не имеет.

на JS это можно записать

На js можно, на схемке нет.

Я имею в виду, что это семантически эквивалентно, просто в схеме это подковерная возня, а в JS можно записать явно.

в JS можно записать явно

Конкретно в этом примере копирование кстати есть, но вообще в js как и в жабке объекты не копируются, а в схемке копируются.

Покажи пример, где есть разница между схемой и JS.

Пардон, лоханулся, в схемке тоже объекты не копируются, awww.

Я не понял, о чем тред. Все объясняют автору в чем разница между value и reference и почему в его языке a=1, b=a, b++, a==1.

Ты чо, бредишь?

Второй тред о новом нике анонiмус-а, что не понятно-то?

https://www.gnu.org/software/mit-scheme/documentation/mit-scheme-ref/Custom-O...

А можешь на схеме круг нарисовать?

у тебя есть биндинг a, который ссылается на ячейку, в которой лежит 1. И есть биндинг b, который ссылается на ячейку с 2.

         +---+
[a] ---> | 1 |
         +---+

         +---+
[b] ---> | 2 |
         +---+

Далее, ты вызываешь функцию, которой передаешь a в качестве аргумента.

Если передача будет по ссылке, то будем иметь такую картину:

         +---+
[a] ---> | 1 |
         +---+
           ^
           |
[x] -------+

Если по значению, то такую:

         +---+
[a] ---> | 1 |
         +---+

         +---+
[x] ---> | 1 |
         +---+

Вот тут и происходит копирование. Вместо того, чтобы ссылаться на существующую ячейку, мы создаем еще одну точно такую же и копируем туда значение ячейки. Соответственно, set! перепишет значение в той ячейке, на которую указывает x, т.е. изменится копия, а оригинал не будет затронут. Потому ячейка, на которую указывает a изменяться не будет.

Проблема в том, что случай

         +---+
[a] ---> | 1 |
         +---+

         +---+
[x] ---> | 1 |
         +---+

Изменяем ячейку, на которую указывает [x]

         +---+
[a] ---> | 1 |
         +---+

         +---+
[x] ---> | 2 |
         +---+

         +---+
[a] ---> | 1 |
         +---+
           ^
           |
[x] -------+

Изменяем биндинг [x] так, чтобы он указывал на новое значение:

         +---+
[a] ---> | 1 |
         +---+

         +---+
[x] ---> | 2 |
         +---+

И именно это имеет в виду ТС, как мне кажется.

у тебя что идентификатор, что 1 в единственном экземпляре в программе находятся.

нед, единица в двух экземплярах. Одна в а, другая - в х.

Штука в том, что set! в схемке не вводит никаких новых биндингов. Оно меняет значение.

Т Ы О П Я Т Ь В Ы Х О Д И Ш Ь Н А С В Я З Ь

Ы

О

П

Я

Т

Ь

В

Ы

Х

О

Д

И

Ш

Ь

Н

А

С

В

Я

З

Ь

Но это ведь просто реализация. Концептуально разницы нет.