Можно ли создать единый язык программирования высокого уровня для всего?

А динамическая типизация для пользователя - это возможность операций над переменными во время выполнения без явного приведения к типу.

Ещё один любитель придумывать свои определения общепринятым терминам. То, что ты описал, — это неявное приведение типа и/или слабая типизация.

А то иначе можно было сказать, что какой-нибудь Python — это не динамически типизированный ЯП, а C — динамический.

PHP кстати в этом плане здорово упрощает человеческую жизнь, иначе бы половина кода наверное состояла из atoi() и itoa().

Разве что в helloworld-ах, на практике всё-таки обычно нужно парсить ввод явно руками и обрабатывать ошибки.

Даю своё высочайшее соизволение. Создавай.

Это талант, напутать вообще все, и с умным видом учить других %)

По большей части, кмк, питон программисты просто не хотят указывать тип переменной явно, а хотят чтобы интерпретатор сам догадался какой нужен и подставил его. И это в их понимании есть «динамическая типизация».

В питоне:

0. Любая переменная имеет тип и только один тип
1. переменная с именем «а» типа «А» может быть переиспользована для хранения переменной типа «Б»

a = 100
a = Foo()

2. Если не происходило переприсваивания тип переменной не может измениться
3. Интерпретатор не «догадываеся о типе», тип является неотлемлемой частью инстанса

print(type(a)) # Это не угадывание!!!!

4. Типы в питоне динамические, это значит, что если не применять специальных ограничений, то следующие операции разрешены:

a). переменные не built-in классов могут изменять состав своих полей и методов в рантайме

б). Не built-in классы могут изменять состав своих полей и методов в рантайме

в). Классы могут быть определены в рантайме

вот ЭТО понимается под «динамической типизацией в питоне»

Ещё один любитель придумывать свои определения общепринятым терминам.

Вчитайся внимательно в то, что я писал, и не придумывай того, чего я не писал.

Разве что в helloworld-ах, на практике всё-таки обычно нужно парсить ввод явно руками и обрабатывать ошибки.

Нет, просто в листинге.

Давай проще. Берем любой существующий маломальски толстый код на любимом С. Пофиг чего, блокнота, гимпа, хромиума. Там используются преобразования типов?

Если да - значит динамическая типизация все же необходима и должна быть. Иначе бы, как я писал выше, в кодах «праффесианальных праграмистов на Сишечке» не было бы этой лапши из itoa\atoi.

ну вы же сейчас путаете динамическую/статическую типизацию и строгую/нестрогую типизацию

Динамическая типизация это в частности, когда мы можем не указывать тип данных явно – это auto.

Это автоматический вывод типа. Компиляторы стали делать все умнее и умнее, автоматический вывод типа теперь есть во всех современных языках. Компилятор из контекста использования переменной сам подставляет нужный тип, тем самым языки со статический типизацией синтаксически походят на динамические, и часто это выглядит классно т.к. нет необходимости постоянно прописывать типы.

Уже сделали. Подскажу: в его названии всего четыре буквы, начинается на букву Л, вторая буква И.

https://habr.com/ru/companies/yandex/articles/801115/comments/#comment_26662525

Почему гипотетического? D давно придумали.

А как в D выглядит динамическая типизация?

Динамическая типизация это когда я могу написать код вида

function length2(p) {
  return p.x * p.x + p.y * p.y;
}

function unit_length2(id) {
  const resp = fetch("/unit/" + id);
  const resp_body = JSON.parse(resp.body);
  return length2(resp_body.position);
}

В общем когда разница между статически определёнными структурами (т.е. определёнными до запуска программы) и динамически определёнными структурами (т.е. определёнными во время работы программы) размывается.

Рефлексия частично позволяет перекрыть эту разницу в статически-типизированных ЯП.

А auto есть нынче практически в каждом языке программирования и это просто синтаксический сахар. В том же rust есть фича shadowing, которая позволяет переопределять переменную с тем же именем и с другим типом. Что-то вроде

let x = 1
let x = x.to_string()

Но это, конечно, не является динамической типизацией. По сути это простой синтаксический сахар для чего-то вроде

let x_1: int32 = 1
let x_2: string = x_1.to_string()

Можно ли создать единый язык программирования высокого уровня для всего?

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

СИ стал стандартом в 80-х на нем начали писать почти все, на нем написаны ядра операционных систем и базы данных, и много чего еще.
Потом когда появилась нужда писать на Cи что-то прикладное и запутанное сумеречному гению пришла идея добавить в Си классы и так появился C++. Это был идеальный язык, ведь он был «пригоден и для низкоуровневой работы и для написания прикладного ПО» Правда он оказался очень сложным, теперь говорят что чтоб стать хорошим программистом на С++ на нем нужно писать 10 лет. И даже так никто не спасет от фрагментации компиляторов, куцей стандартной библиотеки и ошибок работы с памятью.
В общем другая сумеречная личность посмотрела на это безобразие и решила сделать идеальный язык который будет походить на C++ но будет проще – «C++ without the guns, knives or clubs.», теперь он известен под именем Java.
Микрософт на это посмотрела и поняла что можно сделать еще лучше, еще более идеальный язык но только для платформы Windows. Так появились C# с .NET.
Время шло и кто-то решил что все пошло не туда, рантаймы слишком сложные, GC слишком не предсказуемы, нужно отбросить старые концепты и создать идеальный язык на котором можно будет писать все, от ядер операционных систем до прикладного софта. Без GC но с безопасной работой с памятью заложенной на уровне концепций компилятора. Так появился Rust.

В своем первом комменте я выразился несколько мутно. Моя мысль была в том, что обычному программисту на питоне или js, который не погружается глубоко в язык, не хочется указывать тип явно и эту возможность он воспринимает как «динамическая типизация», что, конечно, с формальной т.з. ей не является.

1. переменная с именем «а» типа «А» может быть переиспользована для хранения переменной типа «Б»

звучит немного некорретно, правильней было бы сказать

«идентификатор переменной с именем «а» типа «А» может быть переиспользован для представления переменной типа «Б»»

a = 100

Тут интерпретатор считает на основе своих правил, что это целый тип, и это я называю «угадыванием», т.к. в явном виде тип не задан, и если я где-то выше написал a=1.1, то после этой строчки тип внезапно может измениться, что кажется несколько странным с логической т.з.:

a = 1.1
print(type(a))

a = 100
print(type(a))

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

PS: для меня типизация в питоне это какой-то дикий синтаксический сахар вокруг ссылок, работа которого часто непонятна и кажется странной, и с каждым годом с развитием языка это становится все запутанней и запутанней.

то что вы пытаетесь выразить называется «утиная типизация» и «вывод типов» и это ортогонально динамической типизации. Вывод типов присутствует, например, в расте. В расте же, есть перекрытие ранее объявленной переменной. Это нифига не делает его динамическим.

Моя мысль была в том, что обычному программисту на питоне или js, который не погружается глубоко в язык, не хочется указывать тип явно

А необычному? В питоне вообще нельзя ничего явно типизировать, от слова совсем.

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

И снова здравстуй раст

https://www.thorsten-hans.com/shadowing-temporary-mutability-rust/

Можно, разрешаю, создавай

Чтобы все эти инсинуации прекратить, давайте попробуем такое определение «любая переменная в любом месте кода в любом контексте в любой момент времени может иметь любой тип заранее не известный до момента выполнения операции над этой переменной - это суть динамическая типизация». С таким определением все согласны?

Или иначе, никами средствами статического тайп-чекинга невозвозможно точно предсказать значение типа в рантайме

Переменная в питоне не имеет типа. Тип имеет объект, который она хранит.

Непонятно.

Под динамической типизацией обычно подразумевают связывание переменной с ее типом в процессе работы программы, т.е. позднее связывание… Английского термина для этого я не знаю. Есть dynamic type checking, но это другое. В ISO 2382 нет определения для чего-то, что можно было бы перевести на русский как «динамическая типизация», что намекает на то, что само понятие весьма и весьма мутное.

2122355
variable
quadruple, established by a declaration or an implicit declaration, that consists of an identifier, a set of data attributes, one or more addresses, and data values, where the relationship between the addresses and the data values may vary

Note 1 to entry: In some programming languages, the addresses may vary, hence the associated data values may vary. In other programming languages, the addresses remain fixed, but the associated data values may change during execution.

Note 2 to entry: variable: term and definition standardized by ISO/IEC [ISO/IEC 2382-15:1999].

Note 3 to entry: 15.03.03 (2382)

2122374
data type
datatype
defined set of data objects of a specified data structure and a set of permissible operations, such that these data objects act as operands in the execution of any one of these operations

Note 1 to entry: Example: An integer type has a very simple structure, each occurrence of which, usually called value, is a representation of a member of a specified range of whole numbers and the permissible operations include the usual arithmetic operations on these integers.

Note 2 to entry: The term "type" may be used instead of "data type" when there is no ambiguity.

Note 3 to entry: data type; datatype: terms and definition standardized by ISO/IEC [ISO/IEC 2382-15:1999].

Note 4 to entry: 15.04.01 (17.05.08) (2382)

2122349
dynamic
pertaining to a data attribute, whose values can only be established during the execution of all or part of a program

Note 1 to entry: Example: The length of a variable-length data object is dynamic.

Note 2 to entry: dynamic: term and definition standardized by ISO/IEC [ISO/IEC 2382-15:1999].

Note 3 to entry: 15.02.15 (2382)

2121821
dynamic binding
binding performed during the execution of a program

Note 1 to entry: dynamic binding: term and definition standardized by ISO/IEC [ISO/IEC 2382-7:2000].

Note 2 to entry: 07.02.28 (2382)

2121823
late binding
characteristic of programming languages that perform most bindings during execution, usually to achieve flexibility

Note 1 to entry: Examples: dBASE, Smalltalk.

Note 2 to entry: late binding: term and definition standardized by ISO/IEC [ISO/IEC 2382-7:2000].

Note 3 to entry: 07.02.30 (2382)

Если говорить о С++, то интерпретация данных относящихся к переменной может меняться (приведение типов, вызов virtual методов и пр.), что можно интерпретировать как изменение ее типа в процессе работы программы, соотв. можно сделать вывод о том, что в С++ есть элементы динамической типизации. Если же считать шаблоны тоже программным кодом, а их компиляцию – исполнением этого программного кода (что по сути и есть, т.к. шаблоны это код для компилятора), то там динамическая типизация в полный рост присутствует.

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

a = 1
b = 1 

это не переменные, у них id одинаков и это константы, под которые память в программе не выделена (они «хранятся» в машине-интерпретаторе).

В итоге с формальной т.з. можно сказать что и в Python, и в C++ есть элементы динамической типизации.

Уже есть такой, очень супервысокоуровневый - «русский язык» называется:)

Вот два стандарта для него:

ГОСТ 34.602.89 «Техническое задание на создание автоматизированной системы»;
ГОСТ 19.201-78 «Техническое задание. Требования к содержанию и оформлению».

Годится для создания любых проектов на любых платформах!

Да все просто

$ node
Welcome to Node.js v17.9.1.
Type ".help" for more information.
> JSON.parse("123")
123
> JSON.parse("[123]")
[ 123 ]

В С++ ни auto, ни умные указатели, ни шаблоны такое не смогут, можно сделать кое-что другое, что JSON.parse будет возвращать объект с методами getInt, getArray, и т.д. но это будет не статическая типизация, а «эмуляция» динамической типизации внутри статической.

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

это не переменные, у них id одинаков и это константы, под которые память в программе не выделена

в питоне первые 256 интегеров закешированы

В итоге с формальной т.з. можно сказать что и в Python, и в C++ есть элементы динамической типизации.

виртуальной машине питона вообще пофигу какой тип у переменной. Как по-вашему, почему следующий код валиден и работает?

def double(a):
   return a + a


print(double(10))
print(double("abc"))

1. виртуальная машина положит на стек объект типа PyObject. У этого объета есть указатель на значение, указатель на класс и указатель на хеш-таблицу атрибутов объекта.
2. а + а рассахариватеся в а.__add__(a)
3. ВМ ищет ключ с именем __add__ в хеш таблице
4. Если не нашла, идет в класс и ищет __add__ в хеш-таблице класса
5. Если нашла - излекает из хеш-таблицы функцию и вызывает её, если не нашла кидает исключение

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

К чему этот текст?

Я указал на то, что строгого определения динамической типизации нет. Я привел определение переменной. Я привел определения типа данных. Я привел определение «dynamic» в контексте программы.

Как ты определяешь динамическую типизацию опираясь на эти определения?

я целых два дал определения, не нравится - да и хер с тобой

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

После того как эта корректность проверена, она не может «поломаться» на этапе выполнения программы, все положения, основанные на системе типов, сохраняются неизменными.

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

Вот и всё.

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

А как только у нас появляется код, который пишет код, то все вообще превращается в муть. Проверить корректность шаблона в С++ это в общем случае алгоритмически неразрешимая задача.

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

Проверяется не «корректность шаблона» в пустоте, а логические соответствия между разными утверждениями. Например, если нам встречается утверждение a + b, то значит должна быть функция либо метод operator+(), подходящий для данных типов. Если такой функции или метода не объявлено, значит обнаружена ошибка.

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

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

Python – аннотация типов – это же проверка корректности части программы при помощи системы типов данного языка.

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

Аннотация типов есть и питоне, и в перл, и в js. В тоже время в С++ можно писать шаблоны без constraints, и непонятно что там будет проверяться, ведь тип данных это не только формат данных, но и «a set of permissible operations» на них…

Я указал на то, что строгого определения динамической типизации нет.

Да есть довольно четкое разделение, связаное с реализацией. При статической типизации все типы определяются на этапе компиляции за счет чего известен размер переменных, под инт32 тогда можно выделить 4 байта и ни битом больше. При динамической типизации тип хранится в райнайме и размер памяти, выделенной под переменную может менятся. Тут уже нельзя выделить под инт 4 байта, потому что нужно еще и тип хранить, если вдруг этот инт станет флоатом. Допустим функция принимает инт, при статической типизации в стек заталкивается четырехбайтный инт, и код функции работает с ним. При динамической же, в стек заталкивается НЕЧТО (PyObject про который писал FishHook), что может быть и интом, и флоатом, и даже строкой, а функция внезапно тоже должна уметь все это преобразовать (если типизация слабая). Отсюда и растут всякие проверки на корректность при компиляции, потому что компилятору нужно вывести все типы еще до запуска. Так то и при динамической типизации есть проверки на этапе компиляции, например через тайпхинтинг.

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

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

Так то и при динамической типизации есть проверки на этапе компиляции, например через тайпхинтинг.

не в питоне только, а то они щас набегут

Да, точно, это только аннотации, интерпретатору на них наплевать.

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

Но это про динамические языки, а не про динамическую типизацию.

Вот есть у нас переменная А.

Мы написали код

А = 1
А = "pi"

это пример динамической типизации? На мой взгляд, это не так, поскольку переменная А в выражении A=1 и переменная A в выражении A=«pi» это разные переменные (в соотв. с определением переменной приведенного выше), у них только идентификаторы совпали.

А если я напишу код

char A = 1;
int B = 2 + A;

то это будет примером динамической типизации? Ведь тут у переменной A был тип char, но в выражении он превратился в int (новая переменная для A типа int в выражении не появляется, тут чисто promotion типа).

void swap(auto A, auto B)
{
    auto C;
    C = A;
    A = B;
    B = C;
}

Это пример динамической типизации? Тут тип будет определен только на этапе исполнения этого кода компилятором (шаблон это код для генерации кода компилятором). Но является ли A и B тут переменными? На мой взгляд – нет, не являются, согласно определению переменной приведенному выше, до тех пор пока они не превратятся в конкретные double A и double B (например), при компиляции программы в исполняемый код.

то это будет примером динамической типизации?

вот смотри, есть такой питоний код

class Foo:
   pass


def say(obj):
   obj.say()


foo = Foo()
if today == "Friday":
   say(foo)

он абсолютно корректен, он скомпилируется и будет работат, но будет падать с ошибками по пятницам

есть вот такой код

class Foo:
   pass


def say(obj):
   obj.say()

foo = Foo()
foo.say = lambda s: print("Go love yourself")
say(foo)

он тоже абсолютно корректен и работает даже по пятницам. При этом, заметь, с типом Foo никаких изменений не случилось и с функцией тоже. Вопрос философский, изменился ли тип переменной foo в процессе выполнения. С точки зрения питона - нет. С точки зрения теории типов, наверное, да. Но для нас очевидно, что типизация здесь динамическая - переменная после её объявления не соответсвует типу аргумента функции, а потом внезапно начинает соответствовать. Как так? Ну потому что типизация здесь - ДИ мать её НА блин МИЧЕСКАЯ. Компренде хоть сейчас то?

это пример динамической типизации?

Нет.

то это будет примером динамической типизации?

Нет.

Это пример динамической типизации?

Нет. При динамической типизации шаблоны не нужны. Их можно использовать, чтобы сделать «как при динамической типизации» но более эффективно, но под капотом там будут происходить совершенно другие вещи, чем при дин. типизации.

Нужны еще примеры)

Нет, не понял. Тип данных остался тот же. В переменной foo ты добавил данные, которые являются функтором. В первом случае ты попробовал обратиться к отсутствующим данным, получил падение, во втором случае ты обратился к существующим данным, падение не получил. Где тут динамическая типизация? Тип же остался тот же, что до foo.say = …, что после.

Если я в С++ в классе заведу словарь ключ-функтор и буду обращаться к нему, то получу такой же эффект.

Если я в С++ в классе заведу словарь ключ-функтор и буду обращаться к нему, то получу такой же эффект.

А также отсутствие в этом случае тех гарантий, которые дает стат. типизация. WAIT, OH SHI…

Если я в С++ в классе заведу словарь ключ-функтор и буду обращаться к нему, то получу такой же эффект.

отлично, а теперь представь что в языке ВСЕ объекты ЛЮБЫЕ это объеты одного и того же типа к которому присобачена хеш-таблица атрибутов и дот-нотация на самом деле обращается к хеш-таблице. Вот это и будет то, как работает питон

Тип же остался тот же,

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

Ну я знаю это про питон, но какое отношение это имеет к динамической типизации? Определение надо давать как-то привязываясь к определениям переменной, типа данных и dynamic, и сопроводить примером иллюстрирующим качественное отличие от того, где нет динамической типизации.

Я это пока не понимаю. Мне понятен термин интерпретируемый язык, можно даже сказать динамически интерпретируемый язык – интерпретируемый язык, у которого код программы может меняться в процессе его исполнения интерпретатором.

Но смысл термина динамическая типизация мне пока непонятен, т.е. я не могу четко сказать почему С++ это не язык с динамической типизацией, а Pуthon это язык с динамической типизацией.

Точка входа в понимание этого термина это то, что тип переменной может меняться в ходе исполнения программы. Но в С++ переменные можно приводить к другому типу, чем это не изменение? А в python если мы меняем тип переменной, то переменная обычно (всегда?) создается заново, т.е. это не смена типа…

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

class Foo:                                                                                                                                                                                          
    pass                                                                                                                                                                                            
                                                                                                                                                                                                    
                                                                                                                                                                                                    
def say(obj):                                                                                                                                                                                       
    obj.say()                                                                                                                                                                                       
                                                                                                                                                                                                    
                                                                                                                                                                                                    
foo = Foo()                                                                                                                                                                                         
print(type(foo))                                                                                                                                                                                    
foo.say = lambda s: print("Go love yourself")                                                                                                                                                       
print(type(foo))

одно и тоже.

Ты просто изменил данные относящиеся к переменной foo – список медотов проассоциированных с объектом, но ты не изменил ее тип.

Определение надо давать как-то привязываясь к определениям переменной

Еще нужно добавить передачу аргументов в функции

Но в С++ переменные можно приводить к другому типу, чем это не изменение?

Если в С++ у объекта есть свойство int, то его нельзя будет изменить на float. В python можно.

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

нет, это язык который компилируется в байт-код виртуальной машины а не реальной, и байт-код исполняется виртуальной машиной а не центральным процессором

т.е. я не могу четко сказать почему С++ это не язык с динамической типизацией,

потому что тип перемонной должен быть известен на момент компиляции

Но в С++ переменные можно приводить к другому типу, чем это не изменение?

приведение к типу не изменяет ни одного байта в памяти, приведение типа ТОЛЬКО сообщает компилятору как компилировать программу все происходит НА ЭТАПЕ КОМПИЛЯЦИИ, примеры которые я вам дал работают в рантайме и ТОЛЬКО в рантайме.

А в python если мы меняем тип переменной,

тип переменной в питоне - это мгновенное значение типа ассоциированного с ней объекта

А так, то по простому, если мы не указываем тип переменной и можем произвольно добавлять к ней свойства, и программа не падает

программа не падает на этапе компиляции, потому что компилятору все равно какой тип будет в рантайме, потому что скомпилированный байт-код абсолютно одинаковый для любых типов. Программа падает в рантайме, потому что ОБРАЩЕНИЕ к свойству или методу это РАНТАЙМ операция в динамических языках. В си свойства и методы резолвятся компилятором или линковщиком - хрен его знает чем, я не сишник - но в процессе компиляции, когда программа исполняется там есть только уже известные адресса

Ничего не понял. Приводи конкретные примеры, пожалуйста, и пояснение, почему это изменение типа.

Если в С++ у объекта есть свойство int, то его нельзя будет изменить на float. В python можно.

В C++ есть union

union MyType {
    int a;
    float b;
};

MyType var;
var.a = 1;
var.b = 1.1;

Чем это не изменение типа var c int на float? (хотя по факту это все тип MyType, который может быть как int, как и float).

Как я указал выше, в питоне если ты меняешь/добавляешь/удаляешь свойство объекта, то тип объекта не меняется.

но ты не изменил ее тип.

я выше так и сказал - с точки зрения питона тип тот же. С точки зрения теории типов - ну, ответьте на вопрос, что такое тип. Если под типом понимать «нечто что имеет свойства А, Б и Ц» то тип изменился

Чем это не изменение типа var c int на float?

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

Чем это не изменение типа var c int на float?

Типа чего? var имеет тип MyType, a int, b float. Никакой тип не меняется. А вот сделать union для любых типов не получится.

в питоне если ты меняешь/добавляешь/удаляешь свойство объекта, то тип объекта не меняется

Да, тип объекта не меняется. В JS вообще у всех объектов тип Object) Но C++ ты не можешь добавлять/удалять свойства, менять их тип, а c дин. типизацией такое можно.

Так опять вернулись к тому же – твой посыл, что динамическая типизация это когда рантайм, потому что в рантайме код интерпретируется постепенно. Ссылаешься на то, что какие-то свойства меняются, но свойства это не тип данных, это данные переменной, если язык сам говорит, что тип не изменился и id переменной не изменился, то тип и переменная не изменилась, кмк, изменились частично данные, которые она хранит. Это не изменение типа на мой взгляд, т.е. связывание переменная - тип данных не изменилось в ходе работы программы. То, что эти данные оформлены как метод объекта – ну так это синтаксический сахар, которого в питоне на целый сахарный завод хватит.

вам ruby+ffi мало?