Программисты зря тратят время: PythoC — это худший способ подружить Python и C

Языки программирования Python и C связаны гораздо теснее, чем кажется на первый взгляд. Эталонный интерпретатор Python написан на C, и огромное количество сторонних библиотек для Python — это, по сути, обертки для кода на C. Более того, уже давно существуют способы генерировать код C из Python.

Обычно, когда говорят о генерации C-кода из Python, имеют в виду библиотеки вроде Cython. Они используют аннотированный типами Python-код, чтобы создавать модули расширения на C. Это позволяет значительно ускорить «узкие» места в программах.

Однако недавно появился новый проект под названием PythoC, который предлагает совершенно другой подход. Он тоже использует Python с подсказками типов для программной генерации C-кода, но его основная цель — создание автономных программ. К тому же, у него гораздо больше возможностей для генерации кода на этапе компиляции, чем у Cython.

Видео от DGL.RU

Создатели PythoC описывают свою концепцию фразой: «Исполнение на уровне C, компиляция на движке Python». Проект все еще находится на ранней стадии, но в нем уже достаточно рабочих функций, чтобы на него можно было взглянуть. Правда, первый взгляд вызывает скорее недоумение, чем восторг.

Базовая программа на PythoC

Чтобы понять, как это работает, достаточно посмотреть на простой пример:

from pythoc import compile, i32

@compile
def add(x: i32, y: i32) -> i32:
    return x + y

if __name__ == "__main__":
    print(add(10, 20))

Чтобы указать, какие функции в модуле нужно скомпилировать в C, используется декоратор @compile. При этом необходимо предоставить подсказки типов для результата и каждого параметра. Обратите внимание, что импортировать тип i32 нужно из самого PythoC, а не использовать встроенный в Python int. Это означает, что вы работаете с машинными целыми числами, а не с числами произвольного размера из Python.

Когда вы запустите эту программу, то после небольшой задержки получите на выходе число 30. Задержка возникает потому, что C-код компилируется «на лету» каждый раз, когда вы запускаете программу. В PythoC пока нет механизма для повторного использования скомпилированного кода при вызове из Python, как это делает Cython.

На первый взгляд это кажется серьезным ограничением. Но в этом и заключается вся суть проекта. Вы можете использовать PythoC как систему генерации кода для программ на C, которые работают независимо, а не как C-модули, которые импортируются в Python.

Генерация автономных программ на C

Вот еще одна версия той же программы, но с другим поведением:

from pythoc import compile, i32, ptr, i8
from pythoc.libc.stdio import printf

@compile
def add(x: i32, y: i32) -> i32:
    return x + y

@compile
def main(argc: i32, argv: ptr[ptr[i8]]) -> i32:
    printf("%u\n", add(10, 20))

if __name__ == "__main__":
    from pythoc import compile_to_executable
    compile_to_executable()

Первое, что бросается в глаза, — это блок внизу. Функция compile_to_executable() делает именно то, что обещает ее название. Вызовите ее, и текущий модуль скомпилируется в исполняемый файл с тем же именем. В него войдут все функции, которые помечены декоратором @compile.

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

Наконец, когда вы запустите эту программу, сгенерированный исполняемый файл (который появится в подкаталоге build) не запустится автоматически. Вам придется запустить его самостоятельно. Цель здесь — создать автономную программу на C, которую нельзя будет отличить от той, что вы написали вручную, но с использованием синтаксиса Python.

Эмуляция возможностей C

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

Вы уже видели, как использовать аннотации типов для указания примитивных типов данных. Аналогично можно использовать аннотацию ptr[T], чтобы описать указатель, и array[T, N] для N-мерных массивов типа T. Вы можете создавать структуры, объединения и перечисления, если будете декорировать классы Python. Все обычные операторы и операции управления потоком (кроме goto) будут работать. Для switch/case просто используйте match/case, хотя сквозные case (fall-through) недоступны.

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

Генерация кода во время компиляции

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

Вот пример из документации PythoC:

from pythoc import compile, struct, i32, f64

def make_point(T):
    @struct(suffix=T)
    class Point:
        x: T
        y: T
    
    @compile(suffix=T)
    def add_points(p1: Point, p2: Point) -> Point:
        result: Point = Point()
        result.x = p1.x + p2.x
        result.y = p1.y + p2.y
        return result
        
    return Point, add_points

Point_i32, add_i32 = make_point(i32)
Point_f64, add_f64 = make_point(f64)

Функция make_point(T) принимает аннотацию типа (i32, f64) и генерирует во время компиляции специализированные по типу версии класса Point и функции add_points. Параметр suffix для @compile означает «изменить имя сгенерированного объекта так, чтобы в имени использовался тип». Так, например, Point становится Point_i32 и Point_f64, что в C является одним из способов различать несколько версий одной и той же функции с разной сигнатурой.

Функции безопасности памяти

Ошибки, которые могут возникнуть из-за ручного управления памятью в C, удручающе знакомы любому, кто использует этот язык. В Cython есть функции безопасности памяти для решения этой проблемы, но PythoC предлагает уникальные функции на основе типов.

Одна из них называется «линейные типы». Импорт linear позволяет вам сгенерировать «доказательство», обычно для сопровождения выделения памяти, которое должно быть «потреблено», когда та же память освобождается. Если у вас нет соответствующего consume(prf) для каждого prf=linear(), компилятор PythoC выдаст ошибку во время компиляции. Это позволяет автоматизировать большую часть ручной проверки и централизовать ее на этапе компиляции, а не во время выполнения.

Другая функция безопасности на основе типов — это «типы уточнений» (refinement types). Идея здесь в том, что вы можете определить функцию для выполнения определенного вида проверки — например, на нулевой указатель — с булевым результатом. Затем вы можете использовать функцию refine() для передачи значения в эту функцию и получения обратно типа, специфичного для этой функции. Это позволяет компилятору убедиться, что тип должен быть обработан каким-то образом перед возвратом, и позволяет обрабатывать общие проверки в одном месте вашего кода.

Возможные будущие направления

PythoC все еще очень молод, поэтому его будущее развитие относительно открыто. Одна из возможностей заключается в том, что он мог бы более тесно интегрироваться с Python во время выполнения. Например, декоратор @cached мог бы компилировать модули один раз, заранее, а затем повторно использовать скомпилированные модули, когда их вызывают из Python, вместо того чтобы перекомпилировать их при каждом запуске.

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

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

Ваш любимый Python для ИИ — большая ошибка. Пора переходить на JavaScript