Ласкаво прошу в розділ про Python, якщо хочете там вилити.
Так, мови поділяються на дві категорії: ті, які лають, і ті, якими не користуються. У Python-а це чи не основна халепа - неочевидні передачі посилань замість значень. Але є ж і переваги.

+ за TypeScript, обов'язково його розгляну. Та спочатку мені треба JavaScript довчити.

Я абсолютно не пам'ятаю, що я робив 2 місяці назад. Іноді доводиться повертатись до давно написаного коду і читати його як чужий. На Haskell я б не зміг так.

• Опис типів (структури, класи). Мені зручно думати про абстрактні типи як про класи об'єктів, які об'єднують в собі дані і методи їх обробки.

• Наслідування. Будь-який елемент скінченної групи { є елементом групи (довільної), є елементом скінченної множини }, будь-який елемент групи є елементом множини, і будь-який елемент скінченної множини є елементом множини (довільної). Таких послідовностей наслідування там багато.

• Поліморфізм. Зберігати групи можна по різному, відповідно і поведінка формування груп має бути різною, і способи отримання елементів мають бути різними (загалом).

Якщо виникають питання по коду то задавайте, все поясню.

Щоб зробити робочий продукт (SVG редактор), треба :

1. прочитати специфікацію по SVG (це вже купа роботи),

2. запрограмувати відрисовку кожного елемента (а їх там з пів сотні різних типів).

Навіть якщо відкинути все, і працювати тільки з path, circle і g, то для них потрібна обробка атрибутів.
В мене це була вже друга спроба зробити подібний редактор і вона провалилася.

Якщо в двох словах, то відповідь є в цьому повідомленні вище. А для уявлення загальної картини пропоную переглянути діаграму класів :

...
Тру сторі.

combinations1 :: Int -> [a] -> [[a]]
combinations1 0 _  = return []
combinations1 n xs = do y:xs2 <- tails xs
                        ys <- combinations1 (n - 1) xs2
                        return (y:ys)

{-
ghci> combinations1 2 [0,1,2,3]
[[0,1],[0,2],[0,3],[1,2],[1,3],[2,3]]
ghci> combinations1 3 [0,1,2,3]
[[0,1,2],[0,1,3],[0,2,3],[1,2,3]]
ghci> combinations1 4 [0,1,2,3]
[[0,1,2,3]]
-}

подібне до цього? (це унікальні значення)

+

replicateM2 0 xs = return []
replicateM2 n xs = do
   b <- replicateM2 (n-1) xs
   a <- xs
   return (b ++ [a])

ghci> replicateM2 2 [0,1,2,3]
[[0,0],[0,1],[0,2],[0,3],[1,0],[1,1],[1,2],[1,3],[2,0],[2,1],[2,2],[2,3],[3,0],[3,1],[3,2],[3,3]]
ghci> replicateM2 4 [0,1,2,3]
[[0,0,0,0],[0,0,0,1],[0,0,0,2],[0,0,0,3],[0,0,1,0],[0,0,1,1],[0,0,1,2],[0,0,1,3],[0,0,2,0],[0,0,2,1],[0,0,2,2],[0,0,2,3],[0,0,3,0],[0,0,3,1],[0,0,3,2],[0,0,3,3],[0,1,0,0],[0,1,0,1],[0,1,0,2],[0,1,0,3],[0,1,1,0],[0,1,1,1],[0,1,1,2],[0,1,1,3],[0,1,2,0],[0,1,2,1],[0,1,2,2],[0,1,2,3],[0,1,3,0],[0,1,3,1],[0,1,3,2],[0,1,3,3],[0,2,0,0],[0,2,0,1],[0,2,0,2],[0,2,0,3],[0,2,1,0],[0,2,1,1],[0,2,1,2],[0,2,1,3],[0,2,2,0],[0,2,2,1],[0,2,2,2],[0,2,2,3],[0,2,3,0],[0,2,3,1],[0,2,3,2],[0,2,3,3],[0,3,0,0],[0,3,0,1],[0,3,0,2],[0,3,0,3],[0,3,1,0],[0,3,1,1],[0,3,1,2],[0,3,1,3],[0,3,2,0],[0,3,2,1],[0,3,2,2],[0,3,2,3],[0,3,3,0],[0,3,3,1],[0,3,3,2],[0,3,3,3],[1,0,0,0],[1,0,0,1],[1,0,0,2],[1,0,0,3],[1,0,1,0],[1,0,1,1],[1,0,1,2],[1,0,1,3],[1,0,2,0],[1,0,2,1],[1,0,2,2],[1,0,2,3],[1,0,3,0],[1,0,3,1],[1,0,3,2],[1,0,3,3],[1,1,0,0],[1,1,0,1],[1,1,0,2],[1,1,0,3],[1,1,1,0],[1,1,1,1],[1,1,1,2],[1,1,1,3],[1,1,2,0],[1,1,2,1],[1,1,2,2],[1,1,2,3],[1,1,3,0],[1,1,3,1],[1,1,3,2],[1,1,3,3],[1,2,0,0],[1,2,0,1],[1,2,0,2],[1,2,0,3],[1,2,1,0],[1,2,1,1],[1,2,1,2],[1,2,1,3],[1,2,2,0],[1,2,2,1],[1,2,2,2],[1,2,2,3],[1,2,3,0],[1,2,3,1],[1,2,3,2],[1,2,3,3],[1,3,0,0],[1,3,0,1],[1,3,0,2],[1,3,0,3],[1,3,1,0],[1,3,1,1],[1,3,1,2],[1,3,1,3],[1,3,2,0],[1,3,2,1],[1,3,2,2],[1,3,2,3],[1,3,3,0],[1,3,3,1],[1,3,3,2],[1,3,3,3],[2,0,0,0],[2,0,0,1],[2,0,0,2],[2,0,0,3],[2,0,1,0],[2,0,1,1],[2,0,1,2],[2,0,1,3],[2,0,2,0],[2,0,2,1],[2,0,2,2],[2,0,2,3],[2,0,3,0],[2,0,3,1],[2,0,3,2],[2,0,3,3],[2,1,0,0],[2,1,0,1],[2,1,0,2],[2,1,0,3],[2,1,1,0],[2,1,1,1],[2,1,1,2],[2,1,1,3],[2,1,2,0],[2,1,2,1],[2,1,2,2],[2,1,2,3],[2,1,3,0],[2,1,3,1],[2,1,3,2],[2,1,3,3],[2,2,0,0],[2,2,0,1],[2,2,0,2],[2,2,0,3],[2,2,1,0],[2,2,1,1],[2,2,1,2],[2,2,1,3],[2,2,2,0],[2,2,2,1],[2,2,2,2],[2,2,2,3],[2,2,3,0],[2,2,3,1],[2,2,3,2],[2,2,3,3],[2,3,0,0],[2,3,0,1],[2,3,0,2],[2,3,0,3],[2,3,1,0],[2,3,1,1],[2,3,1,2],[2,3,1,3],[2,3,2,0],[2,3,2,1],[2,3,2,2],[2,3,2,3],[2,3,3,0],[2,3,3,1],[2,3,3,2],[2,3,3,3],[3,0,0,0],[3,0,0,1],[3,0,0,2],[3,0,0,3],[3,0,1,0],[3,0,1,1],[3,0,1,2],[3,0,1,3],[3,0,2,0],[3,0,2,1],[3,0,2,2],[3,0,2,3],[3,0,3,0],[3,0,3,1],[3,0,3,2],[3,0,3,3],[3,1,0,0],[3,1,0,1],[3,1,0,2],[3,1,0,3],[3,1,1,0],[3,1,1,1],[3,1,1,2],[3,1,1,3],[3,1,2,0],[3,1,2,1],[3,1,2,2],[3,1,2,3],[3,1,3,0],[3,1,3,1],[3,1,3,2],[3,1,3,3],[3,2,0,0],[3,2,0,1],[3,2,0,2],[3,2,0,3],[3,2,1,0],[3,2,1,1],[3,2,1,2],[3,2,1,3],[3,2,2,0],[3,2,2,1],[3,2,2,2],[3,2,2,3],[3,2,3,0],[3,2,3,1],[3,2,3,2],[3,2,3,3],[3,3,0,0],[3,3,0,1],[3,3,0,2],[3,3,0,3],[3,3,1,0],[3,3,1,1],[3,3,1,2],[3,3,1,3],[3,3,2,0],[3,3,2,1],[3,3,2,2],[3,3,2,3],[3,3,3,0],[3,3,3,1],[3,3,3,2],[3,3,3,3]]

це звучить, деякою частиною, наче ліниві обчислення в хаскелі

а все решта я просто не догнав... ех

отже:
1 -- в списках-елементах списків значення унікальні (відсутні [0,0,0,0], [1,1,1,1], ...)
2 -- списки-елементи є унікальні, з урахуванням індексів значень ( [1,0,2,3] > [0,1,2,3], бо 1 > 0 -- перший елемент )
при цьому повторів таких же списків-елементів немає
3 -- на вході список з двох елементів -- списків з 4х чисел,
на виході -- список з таких же елементів списків

виникає лише одне запитання -- чому у другому випадку результатів 6, а в першому -- 4 ?

я там вище апнув те, що я раніше тицяв (додав приклад того, що на виході)
у мене там такого не виходило, отже, цей алгоритм трішечки інший ))

Знайшов я кілька програм/сайтів, які обчислюють розміри груп використовуючи генеруючі множини за мілісекунди. В той час як моя програма рахує то хвилинами і годинами. А це означає, що я тупий і не бачу чогось очевидного.

Наприклад Magma (система компютерної алгебри), в них там є приклади як її використовувати, працює моментально.

Продовжу через кілька годин...

.zip-файл з сирцями на GitHub.
Цікаво, пане, як ви їсте - прямо з обгортками, навіть не відкриваючи?

Та я ж не знаю, що там у вас в cs-ах…
От у нас в c-ях отаке

    digit = 0;
    while(((byte)(1 << digit) & digitFlag) != 0)
        ++digit;

пишуть як

    digit = __builtin_ctz(~digitFlag); // а потім перевірити на <=7 замість наступної перевірки знову зсувом і маскою

що вироджується в одну-дві асемблерних команди.

Бачу, совання туди-сюди і бітової роботи багато, але після цього тижня тяжко зконцентруватися, щоб витягти алгоритми, а не peephole-оптимізаціями займатися.
Тут були Bit Twiddling Hacks? (Хоча дещо з того вже застаріло, бо з'явилися процесорні команди для цього і __builtin-ами в С воно швидше).

Мда... З пул реквестом я затупив, треба було потримати його відкритим, щоб інші змогли підняти собі статистику по "code review". Ладно, їх буде ще багато.