CAB>>Если все переменные не изменяемые, то из их определений можно выкинуть весь лишний синтаксис как то "val", "const int" etc., и писать просто "<имя> = <выражение>".
Z>Вы напишите, что решаете проблему избыточности синтаксиса. Мои претензии только к формулировкам.
Нет, я мел ввиду что такой подход позволит сделать синтаксис немножко лаконичней. А основная же задача — сократить использование мутабельных переменных.
Z>Лично я проблемы не вижу. Более того, считаю, что уметь понять изменяемая она или нет важно именно при объявлении переменной.
У меня другой стиль кодирования: я объявляю переменные как "val"(кроме явных случаев, вроде счётчиков для циклов), затем в случае необходимости исправляю на "var".

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

Z>>Оператор = и так изменят только изменяемые переменные Зачем нам еще один?
CAB>Чтобы решить проблему изменяемых переменных, нужно сделать их все не изменяемыми.
Ничего подобного. Чтобы решить проблему изменяемых переменных — нужно отказаться от из использования. Нет переменных — нет проблем.
В конце-то концов, программа — это всего лишь суперпозиция функций из которых есть всего три системных: прочитать байт, напечатать байт и функция if(проверить условие, выполнить, выполнить).

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

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

Ну так давайте основную задачу отделим от задачи лаконичного синтаксиса, они не пересекаются. Лично я счетчик цикла не считаю в полной мере мутабельной переменной, если конечно его не меняют руками. Остальные мутабельные переменные применяю только для оптимизаций или наполнении иммутабельного списка (точнее это более общий паттерн, названия которого я не знаю).

Z>>Лично я проблемы не вижу. Более того, считаю, что уметь понять изменяемая она или нет важно именно при объявлении переменной.
CAB>У меня другой стиль кодирования: я объявляю переменные как "val"(кроме явных случаев, вроде счётчиков для циклов), затем в случае необходимости исправляю на "var".

Так я не про написание, я про чтение. Когда переменная объявляется хочется знать, мутабельная она или нет. Там где она изменяется мы и так это знаем. Поэтому перенос признака мутабельности в место изменения скорее вреден.

Z>Ну так давайте основную задачу отделим от задачи лаконичного синтаксиса, они не пересекаются.
Очень даже пересекаются, например в Scala я не использую "break", так как делать это там довольно геморройно(так сделали потому что это считает плохим стилем).
Z>Лично я счетчик цикла не считаю в полной мере мутабельной переменной, если конечно его не меняют руками. Остальные мутабельные переменные применяю только для оптимизаций или наполнении иммутабельного списка (точнее это более общий паттерн, названия которого я не знаю).
Так же могут быть удобно для вычислений:

//Это могут быть длинные выражения
  val i = 1   
  val j = 3
  var s = j + 1  
  s = j * i + s
  s = if(s == 0) 100 else s
...
  i = 1
  j = 3
  s = j + 1 
  s := (j * i + s)/2
  s := if(s == 0) 100 else s
...

и экономии идентификаторов:

  i = 0
  while(i...){
    ...}
  m = new Map(...)
  i := m.inerator()
  while(i.next()){
    ...}

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

Z>Так я не про написание, я про чтение. Когда переменная объявляется хочется знать, мутабельная она или нет. Там где она изменяется мы и так это знаем. Поэтому перенос признака мутабельности в место изменения скорее вреден.
Зачем делать работу за IDE?:

  i = 1
  j = 2
  ...
  j := 1 + j
  ...
  s = j * i

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

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

Думаю, что ты пошел не в ту степь.

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

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

С тех пор как начал писать на Немерле проблем со случайным изменением изменяеммых переменных у мнея ни разу не было.

def loop1(i)
{
  if (i < /*some size*/)
  {
    //high code...
    def loop2(i)
    {
      if (i < /*some size*/)
      { 
        //do something...       
        loop2(i + 1)
      }
      else i
     }

     loop2(i)
   }
   else      
   { 
     //high code...
     loop1(i + 1)
   }
}

И никаких изменяемых переменных.