Каркас нового языка программирования

F calculate_sacred_number()
   A results = []

   L(hash_algorithm) hashlib:algorithms_available // Обходим все доступные хэш-алгоритмы
                                                  \\ (список включает в себя MD5, SHA...)
      I.unlikely "shake" C hash_algorithm // Пропускаем алгоритмы SHAKE, так как ...
         L.continue
      L(uppercase) 0B..1B // Проверяем варианты написания как строчными, так и ПРОПИСНЫМИ
         L(space)  0B..1B // Проверяем варианты написания с дефисом и через пробел
            L(n)   10..99 // Проверяем все двузначные числа
               A nw = :numbers[n] // Получаем текущее число, записанное словами на англ.
               I uppercase
                  nw .= upper()
               I space
                  nw .= replace(‘-’, ‘ ’)
               A ns = String(n)
               // Считаем хэш от записанного словами числа,
               A digest1 = hashlib:(hash_algorithm, nw.encode()).hexdigest()
               // а также от этого же числа, преобразованного в строку.
               A digest2 = hashlib:(hash_algorithm, ns.encode()).hexdigest()
               L 2 // Проверяем целый хэш, а также первую половину хэша
                  // Оба хэша должны начинаться на первую цифру текущего числа
                  // и заканчиваться на вторую цифру.
                  I  digest1[0] == ns[0] & digest1.last == ns[1]
                   & digest2[0] == ns[0] & digest2.last == ns[1]
                     results [+]= ns
                  // Берём первую половину хэша
                  digest1 = digest1[0 .< (len) I/ 2]
                  digest2 = digest2[0 .< (len) I/ 2]

   assert(results.len == 1) // Должно быть только одно "выигравшее" число
   R results[0]             // Возвращаем это число

// Based on [https://stackoverflow.com/a/8982279/2692494 ‘How do I tell Python to convert integers into words’]
A numbers = "zero one two three four five six seven eight nine".split()
numbers [+]= "ten eleven twelve thirteen fourteen fifteen sixteen".split()
numbers [+]= "seventeen eighteen nineteen".split()
L(tens) "twenty thirty forty fifty sixty seventy eighty ninety".split()
   L(ones) numbers[0..9]
      numbers [+]= I ones == "zero" {tens} E tens‘-’ones

print(calculate_sacred_number())

fn calculate_sacred_number()
   var results = []

   loop(hash_algorithm) hashlib:algorithms_available // Обходим все доступные хэш-алгоритмы
                                                     \\ (список включает в себя MD5, SHA...)
      if.unlikely "shake" in hash_algorithm // Пропускаем алгоритмы SHAKE, так как ...
         loop.continue
      loop(uppercase) 0B..1B // Проверяем варианты написания как строчными, так и ПРОПИСНЫМИ
         loop(space)  0B..1B // Проверяем варианты написания с дефисом и через пробел
            loop(n)   10..99 // Проверяем все двузначные числа
               var nw = :numbers[n] // Получаем текущее число, записанное словами на англ.
               if uppercase
                  nw .= upper()
               if space
                  nw .= replace(‘-’, ‘ ’)
               var ns = String(n)
               // Считаем хэш от записанного словами числа,
               var digest1 = hashlib:(hash_algorithm, nw.encode()).hexdigest()
               // а также от этого же числа, преобразованного в строку.
               var digest2 = hashlib:(hash_algorithm, ns.encode()).hexdigest()
               loop 2 // Проверяем целый хэш, а также первую половину хэша
                  // Оба хэша должны начинаться на первую цифру текущего числа
                  // и заканчиваться на вторую цифру.
                  if digest1[0] == ns[0] & digest1.last == ns[1]
                   & digest2[0] == ns[0] & digest2.last == ns[1]
                     results [+]= ns
                  // Берём первую половину хэша
                  digest1 = digest1[0 .< (len) I/ 2]
                  digest2 = digest2[0 .< (len) I/ 2]

   assert(results.len == 1) // Должно быть только одно "выигравшее" число
   return results[0]        // Возвращаем это число

// Based on [https://stackoverflow.com/a/8982279/2692494 ‘How do I tell Python to convert integers into words’]
var numbers = "zero one two three four five six seven eight nine".split()
numbers [+]= "ten eleven twelve thirteen fourteen fifteen sixteen".split()
numbers [+]= "seventeen eighteen nineteen".split()
loop(tens) "twenty thirty forty fifty sixty seventy eighty ninety".split()
   loop(ones) numbers[0..9]
      numbers [+]= if ones == "zero" {tens} else tens‘-’ones

print(calculate_sacred_number())

T Person
   String name
   Int age

   F (name, age)
      .name = name // or (.).name = name, because (.) is this/self
      .age  = age

A persons = []
persons [+]= Person("Name", 17)

// Translation of Python's `def parenthesize(s: Union[str, bytes]) -> Union[str, bytes]: ...` from [http://neopythonic.blogspot.com]:
F parenthesize(T C (String, Bytes) s)
   ...

// Doubly linked list
T DLListItem[T Type]
   Type& prev // ‘unsafe pointer’/‘unowned reference’ [true weak pointer/reference `Type??` is much more expensive]
   Type? next

   F is_in_list // if method is defined without parentheses, than it must be called also without, i.e.: I it.is_in_list {...} 
      R next != N

T DLList[T Type(DLListItem)] // Type(DLListItem) means that Type must be derived from DLListItem
   Type? first
   Type& last

   F.destructor // destructor is needed/necessary because some list item may be shared, and in that case it will not be removed from the list and also all following items will not be removed
      .clear()

   F clear()
      Type? p = move(first) // this also sets `first` to N
      L p
         p.prev = N
         Type? n = move(p.next) // this also sets `p.next` to N
         p = n // move(n) is not needed here as the compiler put `move` automatically at all places of last use of variable
      last = N

   F append, [+]=(Type &item) // define both method `append()` and operator [+]=
      item.prev = .last
      I .last {.last.next = item} E .first = item
      .last = item

   F calc_len()
      Int len = 0
      L (.)
         len++
      R len

   F L
      F () -> Type& // returns iterator to the first element of this container
         R .first
      F next(it) -> Type&
         R it.next
      F prev(it)
         R it.prev


Т ЛичныеДанные
   Строка имя
   Цел возраст

   Ф (имя, возраст)
      .имя = имя // или (.).имя = имя, так как (.) это this/self
      .возраст = возраст

А массив_лд = []
массив_лд [+]= ЛичныеДанные("Имя", 17)

// Перевод Python-кой записи `def parenthesize(s: Union[str, bytes]) -> Union[str, bytes]: ...` из [http://neopythonic.blogspot.com]:
Ф заключить_в_скобки(Т С (Строка, Байты) с)
   ...

// Двусвязный список
Т ЭлДССписка[Т Тип]
   Тип& пред // небезопасная ссылка/указатель [честный слабый указатель `Тип??` значительно дороже]
   Тип? след

   Ф в_списке // если метод объявляется без скобок, то вызывать его необходимо также без скобок, например: Е эл.в_списке {...} 
      Р след != Н

Т ДССписок[Т Тип(ЭлДССписка)] // Тип(ЭлДССписка) означает, что Тип должен быть производным от ЭлДССписка
   Тип? первый
   Тип& последний

   Ф.деструктор // деструктор нужен, так как какой-то элемент списка может быть shared\разделён, и в этом случае он не будет удалён из списка также как и последующие элементы
      .очистить()

   Ф очистить()
      Тип? п = перем(первый) // это также сбрасывает `первый` в Н
      Ц п
         п.пред = Н
         Тип? с = перем(п.след) // это также сбрасывает `п.след` в Н
         п = с // перем(с) здесь не обязательно, так как компилятор вставляет `перем` автоматически в места последнего использования переменной
      последний = Н

   Ф добавить, добавь, [+]=(Тип &эл) // также может быть полезно для "локализованных" исходных файлов: F append,добавить ...
      эл.пред = .последний
      Е .последний {.последний.след = эл} И .первый = эл
      .последний = эл

   Ф вычисл_длину()
      Цел длина = 0
      Ц (.)
         длина++
      Р длина

   Ф Ц
      Ф () -> Тип& // возвращает итератор контейнера (в данном случае — указатель на первый элемент списка)
         Р .первый
      Ф след(эл) -> Тип&
         Р эл.след
      Ф пред(эл)
         Р эл.пред