Как называются неблагоприятные последствия конкурирующих целей дизайна языка (пример: списки/кортежи, конкатенация/расширение, + и +=)?

Question

Данный:

      L, M = [True], [False] # lists
T, U = (False,), (True,) # tuples

Следующие операторы с использованием , и extend()ОК:

      N = L + M # concatenates two lists with the resulting list assigned to LHS
V = T + U # concatenates two tuples with the resulting tuple assigned to LHS

M += L # extend LHS list using RHS iterable (a list)
L += T # extend LHS list using RHS iterable (a tuple)
M.extend(L) # extend list object using iterable argument (a list)
L.extend(T) # extend list object using iterable argument (a tuple)

U += T # appears to concatenate two tuples: RHS concatenated to original LHS, result gets assigned to LHS

Однако эти утверждения приводят к ошибкам:

      L = L + T # TypeError: can only concatenate list (not "tuple") to list
T = T + L # TypeError: can only concatenate tuple (not "list") to tuple
T += L # TypeError: can only concatenate tuple (not "list") to tuple
T.extend(U) # AttributeError: 'tuple' object has no attribute 'extend'

Я понимаю, что работа с неизменяемыми числовыми типами, такими как int, имеет смысл для удобства (хотя это означает нечто отличное от аналогичного оператора в C/C++, например). И я понимаю, что удобно принимать итерируемую RHS с изменяемым типом последовательности (списком) в качестве LHS.

На каком-то уровне int и tuple похожи (оба неизменяемы) и, следовательно, если работает для int, то «почему бы и нет» для кортежа.

А на каком-то уровне список и кортеж похожи (оба встроенные типы последовательностей) и поэтому если работает со списком LHS, то "почему бы и нет" для кортежа LHS.

Но... это приводит к некоторым не очень интуитивным несоответствиям:

1. Отсутствие поддержки параллельного использования оператора во встроенных типах последовательностей:

• L += iterableизменяет список L на месте, и существующие ссылки на него отслеживают изменение, тогда как ...
• T += iterableвыдает TypeError для кортежа T, если iterable не является кортежем, и если предположить, что LHS и RHS оба являются кортежами, LHS заменяется новым объектом.

2. Изменение смысла двух интуитивно идентичных операций, +=а также :

• L += Tизменяет список L на месте, расширяя его с помощью итерируемой RHS (кортежа T), тогда как ...
• L = L + Tвыдает TypeError, потому что кортеж T не имеет того же типа, что и левый операнд (список L) +.

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