История изменений

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Т.е. в моем понимании, любая работа с типами данных/операндов зависит от выбранной цели. Поэтому, считаю, что надо сначала определить цель, а потом уже рассуждать об пользе/вреде.

PS. Если что, я сторонник точной типизации (не жесткой, а точной) и считаю, что желаемый результат должен достигаться явным указанием в выражениях желаемого результата, в формуле/операндах – что бы взглянул на формулу и все было понятно четко и точно, без необходимости лазить в другие модули или части исходников. Но такого нигде не встречал, поэтому, я пока сторонник жесткой типизации, что бы все проверял и лазил сам компилятор, и если что-то не так, то подсвечивал и не давал компилироваться программе.

Псевдокод, иллюстрирующий мое видение динамической но точной типизации:

a: int = 42
b: str = "foo"
print(a as str + b as str)

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Т.е. в моем понимании, любая работа с типами данных/операндов зависит от выбранной цели. Поэтому, считаю, что надо сначала определить цель, а потом уже рассуждать об пользе/вреде.

PS. Если что, я сторонник точной типизации (не жесткой, а точной) и считаю, что желаемый результат должен достигаться явным указанием в выражениях желаемого результата, в формуле/операндах – что бы взглянул на формулу и все было понятно четко и точно, без необходимости лазить в другие модули или части исходников. Но такого нигде не встречал, поэтому, я пока сторонник жесткой типизации, что бы все проверял и лазил сам компилятор, и если что-то не так, то подсвечивал и не давал компилироваться программе.

Псевдокод, иллюстрирующий мое видение динамической но точной типизации:

a: int = 42
b: str = "foo"
print(a as str + b)

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Т.е. в моем понимании, любая работа с типами данных/операндов зависит от выбранной цели. Поэтому, считаю, что надо сначала определить цель, а потом уже рассуждать об пользе/вреде.

PS. Если что, я сторонник точной типизации (не жесткой, а точной) и считаю, что желаемый результат должен достигаться явным указанием в выражениях желаемого результата, в формуле/операндах – что бы взглянул на формулу и все было понятно четко и точно, без необходимости лазить в другие модули или части исходников. Но такого нигде не встречал, поэтому, я пока сторонник жесткой типизации, что бы все проверял и лазил сам компилятор, и если что-то не так, то подсвечивал и не давал компилироваться программе.

Псевдокод:

a: int = 42
b: str = "foo"
print(a as str + b)

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Т.е. в моем понимании, любая работа с типами данных/операндов зависит от выбранной цели. Поэтому, считаю, что надо сначала определить цель, а потом уже рассуждать об пользе/вреде.

PS. Если что, я сторонник точной типизации (не жесткой, а точной) и считаю, что желаемый результат должен достигаться явным указанием в выражениях желаемого результата, в формуле/операндах.

Псевдокод:

a: int = 42
b: str = "foo"
print(a as str + b)

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Т.е. в моем понимании, любая работа с типами данных/операндов зависит от выбранной цели. Поэтому, считаю, что надо сначала определить цель, а потом уже рассуждать об пользе/вреде.

PS. Если что, я сторонник точной типизации (не жесткой, а точной) и считаю, что желаемый результат должен достигаться явным указанием желаемого результата.

Псевдокод:

a: int = 42
b: str = "foo"
print(a as str + b)

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Т.е. в моем понимании, любая работа с типами данных/операндов зависит от выбранной цели.

PS. Если что, я сторонник точной типизации (не жесткой, а точной) и считаю, что желаемый результат должен достигаться явным указанием желаемого результата.

Псевдокод:

a: int = 42
b: str = "foo"
print(a as str + b)

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Т.е. в моем понимании, любая работа с типами данных/операндов зависит от все зависит от выбранной цели.

PS. Если что, я сторонник точной типизации (не жесткой, а точной) и считаю, что желаемый результат должен достигаться явным указанием желаемого результата.

Псевдокод:

a: int = 42
b: str = "foo"
print(a as str + b)

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Т.е. в моем понимании, любая работа с типами данных/операндов зависит от все зависит от выбранной цели.

PS. Если что, я сторонник точной типизации (не жесткой, а точной) и считаю, что желаемый результат должен достигаться явным указанием желаемого результата.

a: int = 42
b: str = "foo"
print(a as str + b)

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Т.е. в моем понимании, любая работа с типами данных/операндов зависит от все зависит от выбранной цели.

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об этом в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Мне видится, что я все-таки все правильно понял.

Но есть один вопрос: мы рассматриваем конкретные реализации в существующих языках или все-таки рассуждаем об это в общем и целом?

Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

Или вот тут как хотим, что бы было «42foo» или нет?

a: int = 42
b: str = "foo"
print(a + b)

Мне видится, что я все-таки все правильно понял. Не могли бы вы привести пример кода с желаемой динамической типизацией. Еще просьба, если это будет пример кода от реально существующего языка, укажите пожалуйста этот язык, а то, судя по комментариям, тут пишет кто во что горазд, включая песевдокод. Например, («2» == 2) и что бы было true, это как я понял есть псевдокод с желаемым поведением у одного из написавших.

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