Несомненно вам известно о пользе изменяемых переменных:

   i = 0
   while(i < /*some size*/){
     //do something...
     i += 1}

и об их опасности:

   i = 0
   while(i < /*some size*/){
     //high code...
       //copypaste
       i = 0                     
       while(i < /*some size*/){ 
         //do something...       
         i += 1}                 
     //high code...
     i += 1}

Чтобы сделать программирование безопаснее, авторы некоторых языков разделяют переменные на изменяемы и не изменяемые (постоянные переменные ):

   var i = 0
   val j = 0
   i = 1
   j = 1 //<<error

Однако, ИМХО, такой подход не очень эффективен, так как, хоть изменяемых переменных и становится меньше они всё равно остаются.

Но, что если сделать все переменные "почти" неизменяемыми и добавить оператор для их изменения? Т.е. переменные могут быть изменены только одним специальным оператором:

   i = 0   //definition variable
   i := 1  //change variable
   i = 0   //<<error: "i" already defined
   j := 1  //<<error: "j" not defined

Пример:

   i = 0
   while(i < /*some size*/){
     //high code...
       //copypaste
       i = 0                     //<<error             
       while(i < /*some size*/){ 
         //do something...       
         i +:= 1}                 
     //high code...
     i +:= 1}

Что думаете? Хотели ли бы вы такую фичу в вашем ЯП?
Спасибо.

Здравствуйте, C.A.B, Вы писали:


CAB> Что думаете? Хотели ли бы вы такую фичу в вашем ЯП?
CAB> Спасибо.

Очень похожее уже давно есть в некоторых языках.
Например в OCaml нет изменяемых переменных, но стандартная библиотека представляет тип ref
который является изменяемой ссылкой (http://www.cs.cornell.edu/courses/cs3110/2011sp)

let i = ref 0

Соответственно присваивание

i := 123

и даже чтение значения спец оператором (!)

i := !i + 1

Здравствуйте, C.A.B, Вы писали:

CAB> Но, что если сделать все переменные "почти" неизменяемыми и добавить оператор для их изменения? Т.е. переменные могут быть изменены только одним специальным оператором:

А что это даст? При набивании через copy-paste скопируется и этот специальный оператор. При чтении — будет больше бросаться в глаза, что в данной точке происходит изменение переменной? Вряд ли (особенно если запретить присваивание в виде выражения).

Вот если бы это как-то сокращало количество ошибок при написании кода или улучшало его чтение...

ARK>А что это даст? При набивании через copy-paste скопируется и этот специальный оператор. При чтении — будет больше бросаться в глаза, что в данной точке происходит изменение переменной? Вряд ли (особенно если запретить присваивание в виде выражения).

Как минимум поможет статистическому анализатору кода.

Здравствуйте, AlexRK, Вы писали:
ARK>А что это даст? При набивании через copy-paste скопируется и этот специальный оператор.
В некоторых случаях да, но в других(как в примере из стартового поста) ошибка слоиться.
ARK>При чтении — будет больше бросаться в глаза, что в данной точке происходит изменение переменной? Вряд ли
Чтобы бросалось в глаза можно подсвечивать красным в IDE, как var'ы в Scala.
ARK>(особенно если запретить присваивание в виде выражения).
Это ещё зачем(или как)?
ARK>Вот если бы это как-то сокращало количество ошибок при написании кода или улучшало его чтение...
Почему это не сократит количество ошибок?

Здравствуйте, FR, Вы писали:
CAB>> Что думаете? Хотели ли бы вы такую фичу в вашем ЯП?
FR>Очень похожее уже давно есть в некоторых языках.
И как по вашему, оно полезно?

Здравствуйте, C.A.B, Вы писали:

FR>>Очень похожее уже давно есть в некоторых языках.
CAB>И как по вашему, оно полезно?

В функциональном языке конечно полезно.
Все императивное хорошо локализуется.
Но насчет "почти" неизменяемых переменных я сомневаюсь в пользе.
По моему более правильный вариант как раз изменяемые переменные
с доступом спец. операторами, как и сделано в OCaml.

Здравствуйте, C.A.B, Вы писали:

CAB>В некоторых случаях да, но в других(как в примере из стартового поста) ошибка слоиться.

Ну а в таком — нет:

   i := 0
   while(i < /*some size*/){
     //high code...
       //copypaste
       i := 0                     // << no error, тут был copy-paste
       while(i < /*some size*/){
         //do something...
         i +:= 1}
     //high code...
     i +:= 1}

Тут ведь словилась ошибка повторного объявления? В таком случае достаточно объявлять переменные с помощью обязательного ключевого слова типа var.

ARK>>(особенно если запретить присваивание в виде выражения).
CAB>Это ещё зачем(или как)?

Ну чтобы нельзя было писать "somethingVeryVeryLongWithBigParameterList(....., i++ /* где-то в середине вызова побочный эффект (присваивание) */, ......)".

ARK>>Вот если бы это как-то сокращало количество ошибок при написании кода или улучшало его чтение...
CAB>Почему это не сократит количество ошибок?

Если переменные объявляются с помощью var или def, то не вижу мест, где ошибка может быть отловлена с помощью вашего оператора.

CAB>>В некоторых случаях да, но в других(как в примере из стартового поста) ошибка слоиться.
ARK>Ну а в таком — нет:
ARK>

ARK>       i := 0                     // << no error, тут был copy-paste
ARK>

Да, здесь конечно нет.
ARK>>>(особенно если запретить присваивание в виде выражения).
CAB>>Это ещё зачем(или как)?
ARK>Ну чтобы нельзя было писать "somethingVeryVeryLongWithBigParameterList(....., i++ /* где-то в середине вызова побочный эффект (присваивание) */, ......)".
Тогда уж лучше запретить присваивание внутри выражений.
ARK>Тут ведь словилась ошибка повторного объявления? В таком случае достаточно объявлять переменные с помощью обязательного ключевого слова типа var.
ARK>Если переменные объявляются с помощью var или def, то не вижу мест, где ошибка может быть отловлена с помощью вашего оператора.
Хочу сделать как в Python'е без спец. ключевых слов и указания типа(как в С). По идее должно получится лаконичней("i = 5" вместо "val i = 5" или "int i = 5;") и читабельней("=" -> однозначно определение значения, ":=" -> однозначно переопределение).

Здравствуйте, C.A.B, Вы писали:

CAB>Хочу сделать как в Python'е без спец. ключевых слов и указания типа(как в С). По идее должно получится лаконичней("i = 5" вместо "val i = 5" или "int i = 5;") и читабельней("=" -> однозначно определение значения, ":=" -> однозначно переопределение).

Я так делал в одном своем языке. Там
x = 5 это определение, а
x <- 6 это присваивание.
Но присваивание это не переопределение, оно не меняет типа и не вводит новой переменной.

http://thedeemon.livejournal.com/tag/leo

Здравствуйте, C.A.B, Вы писали:

CAB>Хочу сделать как в Python'е без спец. ключевых слов и указания типа(как в С). По идее должно получится лаконичней("i = 5" вместо "val i = 5" или "int i = 5;") и читабельней("=" -> однозначно определение значения, ":=" -> однозначно переопределение).

Направленность языка какая? write once? Или его читать иногда будут? Или даже не иногда, а часто? Лично я категорически против, если по объявлению переменной нельзя понять ее мутабельность. Они совершенно по-разному "считываются" и "обрабатываются". Особенно это заметно на всяких локальных переходах (циклы, ветвления). Там приходится помнить и обновлять "семантику" переменной по ходу чтения. А так как изменяемые имена имеют гораздо больший оверхед, чем неизменяемые, делать все "изменяемым по умолчанию, пусть и специальным оператором" нехорошо. Так что сделайте изменяемым переменным модификатор var и не мучайтесь. var i := 5 будет изменяемой переменной (и ее можно будет потом сразу установить). i = 5 — неизменяемой. Или вообще разнесите операторы по разным переменным. := — всегда для изменяемой. Даже декларация будет i := 5. А i = 5 всегда неизменяемая. (Почти ocaml и получился)

Другой вопрос, нужен ли для императивных языков маркер "определение значения" или нет. Нужно ли с первого взгляда находить, где объявлено имя (и его значение) или нет, нужно ли сканировать в поисках этих переменных, нужно ли их специально выделять в IDE и т.д. Пока мне идея "слабозаметного объявления" не очень нравится, но подробно я обосновать не могу (может, я и ошибаюсь).

Да, и не забудьте следующий сценарий:

final int v1;
final int v2;

if (iAmLuckyToday()) {
  v1 = 100;
  v2 = 5 * v1;
} else {
  v2 = 5;
  v1 = v2 / 5;
}
System.out.println("" + v1 + v2);

Т.е. имена неизменные после инициализации, но вот инициализация зависит от некоторых условий (т.е. не слишком простая). В разных языках конструкция с подобной семантикой реализуется по-разному. Главное, не забудьте и определите, как оно с вашим оператором будет взаимодействовать.

Здравствуйте, maxkar, Вы писали:
M>Направленность языка какая? write once?
Ну, в общем то да, направленность: написал-забыл.
M>Или его читать иногда будут? Или даже не иногда, а часто?
Читать тоже придётся, но предположительно не часто.
M>Лично я категорически против, если по объявлению переменной нельзя понять ее мутабельность. Они совершенно по-разному "считываются" и "обрабатываются". Особенно это заметно на всяких локальных переходах (циклы, ветвления). Там приходится помнить и обновлять "семантику" переменной по ходу чтения. А так как изменяемые имена имеют гораздо больший оверхед, чем неизменяемые, делать все "изменяемым по умолчанию, пусть и специальным оператором" нехорошо. Так что сделайте изменяемым переменным модификатор var и не мучайтесь. var i := 5 будет изменяемой переменной (и ее можно будет потом сразу установить). i = 5 — неизменяемой. Или вообще разнесите операторы по разным переменным. := — всегда для изменяемой. Даже декларация будет i := 5. А i = 5 всегда неизменяемая. (Почти ocaml и получился)
Переменные к которым применялся ":=" можно подсвечивать в IDE, но я ещё подумаю над этим, спасибо.
M>Пока мне идея "слабозаметного объявления" не очень нравится, но подробно я обосновать не могу (может, я и ошибаюсь).
Живут же как-то питонщики
M>Да, и не забудьте следующий сценарий:
Для этого уже давно придумали патерн:

final int v1;
final int v2;
v1,v2 = if (iAmLuckyToday()) {
          v1 = 100;
          v2 = 5 * v1;
          v1,v2
        } else {
          v2 = 5;
          v1 = v2 / 5;
          v1,v2
        }
System.out.println("" + v1 + v2);

Здравствуйте, D. Mon, Вы писали:
DM>Но присваивание это не переопределение, оно не меняет типа и не вводит новой переменной.
Почему не сделали переопределение, еж ли не секрет?

Здравствуйте, FR, Вы писали:

CAB>> Что думаете? Хотели ли бы вы такую фичу в вашем ЯП?
FR>Очень похожее уже давно есть в некоторых языках.
Очень похоже, что все это было еще в Алголе-68.

Здравствуйте, C.A.B, Вы писали:

CAB> Что думаете? Хотели ли бы вы такую фичу в вашем ЯП?
CAB> Спасибо.

Чем это отличается от обычного присваивания, кроме того что другой оператор?
Да и не нужно это ограничение, переменная на то и переменая, чтобы меняться. Пишите простые маленькие функции без наворотов, и ошибок не будет.
Мне больше нравится подход в Go, оператор := используется для объявления переменных с выводом типов. Самая компактная форма из всех, что я видел. Только они не довели начатое до конца — не разрешили использовать этот оператор внутри выражений (для сохранения промежуточных результатов например).

Здравствуйте, C.A.B, Вы писали:

DM>>Но присваивание это не переопределение, оно не меняет типа и не вводит новой переменной.
CAB>Почему не сделали переопределение, еж ли не секрет?

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

Здравствуйте, NeoCode, Вы писали:
NC>Чем это отличается от обычного присваивания, кроме того что другой оператор?
Используется _исключительно_для_переопределения_ т.е. всегда кода нам нужна новая переменная используем "=", и иногда когда хотим переопределить существующую переменную используем ":=". Ну а по большому счёту да, это те-же яйца "=" эквивалентен "var", а ":=" обычному присваиванию.
NC>Да и не нужно это ограничение, переменная на то и переменая, чтобы меняться. Пишите простые маленькие функции без наворотов, и ошибок не будет.
Это помогает ловить ошибки даже в маленьких функциях, большинство из которых могут обходится вообще без переменных(если ЯП способствует).
NC>Мне больше нравится подход в Go, оператор := используется для объявления переменных с выводом типов. Самая компактная форма из всех, что я видел. Только они не довели начатое до конца — не разрешили использовать этот оператор внутри выражений (для сохранения промежуточных результатов например).
Спец. оператор для вывода типов, это ИМХО не очень хорошее решение(лишнее усложнение). Я хочу сделать мощный вывод типов что позволит приблизить синтаксис к динамическим языкам.

Здравствуйте, C.A.B, Вы писали:

Есть проблема:
CAB> Однако, ИМХО, такой подход не очень эффективен, так как, хоть изменяемых переменных и становится меньше они всё равно остаются.

Есть решение:
CAB> Но, что если сделать все переменные "почти" неизменяемыми и добавить оператор для их изменения? Т.е. переменные могут быть изменены только одним специальным оператором:

Я один не понимаю, почему решение не решает проблему? Оператор = и так изменят только изменяемые переменные Зачем нам еще один?

Здравствуйте, Ziaw, Вы писали:
Z>Оператор = и так изменят только изменяемые переменные Зачем нам еще один?
Чтобы решить проблему изменяемых переменных, нужно сделать их все не изменяемыми.
Если все переменные не изменяемые, то из их определений можно выкинуть весь лишний синтаксис как то "val", "const int" etc., и писать просто "<имя> = <выражение>".
Но вот беда, изменяемые переменные иногда, в весьма редких случаях, полезны.
А потому, чтобы всё таки иметь возможность изменять переменные, можно добавить ещё один, специальный оператор для этого — оператор переопределения.
И если не использовать этот плохой, злой оператор, вот так взять и отключить в настройках компилятора, то наступит имутабельное счастье

Здравствуйте, C.A.B, Вы писали:

CAB>Если все переменные не изменяемые, то из их определений можно выкинуть весь лишний синтаксис как то "val", "const int" etc., и писать просто "<имя> = <выражение>".

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