Какие инструменты есть для функционального программирования на C?

Главное, что приходит в голову, - это использование генераторов кода. Хотели бы вы программировать на другом языке, обеспечивающем функциональное программирование, а затем сгенерировать из него код C?

Если это непривлекательный вариант, то вы можете злоупотребить CPP, чтобы получить часть пути. Макросистема должна позволить вам подражать некоторым идеям функционального программирования. Я слышал, что gcc реализован таким образом, но никогда не проверял.

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

Ну, довольно много языков программирования написано на C.И некоторые из них поддерживают функции как первоклассные граждане, языки в этой области - это ecl (встраиваемый общий lisp IIRC), Gnu Smalltalk (gst) (Smalltalk имеет блоки), а также есть библиотеки. для "замыканий", например, в glib2 http://library.gnome.org/devel/gobject/unstable/chapter-signal.html#closure который хотя бы приблизился к функциональному программированию. Так что, возможно, использование некоторых из этих реализаций для функционального программирования может быть вариантом.

Ну или вы можете пойти изучать Ocaml, Haskell, Mozart / Oz или тому подобное ;-)

С уважением

Что в C вы хотите сделать функциональным, синтаксис или семантику? Семантика функционального программирования, безусловно, может быть добавлена ​​в компилятор C, но к тому времени, когда вы закончите, у вас будет практически эквивалент одного из существующих функциональных языков, таких как Scheme, Haskell и т. д.

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

FFCALL позволяет вам создавать замыкания в C - callback = alloc_callback(&function, data) возвращает указатель на функцию, так что callback(arg1, ...) эквивалентен вызову function(data, arg1, ...). Однако вам придется обрабатывать сборку мусора вручную.

Соответственно, блоки был добавлен в форк GCC от Apple; они не указатели на функции, но они позволяют передавать лямбды, избегая при этом необходимости создавать и освобождать хранилище для захваченных переменных вручную (фактически, происходит некоторое копирование и подсчет ссылок, скрытые за некоторым синтаксическим сахаром и библиотеками времени выполнения).

Посмотрите книгу Хартеля и Мюллера, Функциональный C

http://www.ub.utwente.nl/webdocs/ctit/1/00000084.pdf
http://www.cs.bris.ac.uk/~henkm/f2c/index.html

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

Не уверен, как вы будете обрабатывать анонимные функции в C. Однако на машине фон Неймана вы могли бы выполнять анонимные функции в asm.

Не знаю о C. В Objective-C есть некоторые функциональные возможности, GCC на OSX также поддерживает некоторые функции, однако я бы снова рекомендовал начать использовать функциональный язык, их много, упомянутого выше. Я лично начал со схемы, есть несколько отличных книг, таких как «Маленький программист», которые могут вам в этом помочь.

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

#define lambda(return_type, function_body) \
  ({ \
    return_type anon_func_name_ function_body \
    anon_func_name_; \
  })

Используйте так:

int (*max)(int, int) = lambda (int, (int x, int y) { return x > y ? x : y; });

Язык Феликса компилируется в C++. Может быть, это может быть ступенькой, если вы не против C++.

Книгу Хартеля и Мюллера, Функциональный C, в настоящее время (2012-01-02) можно найти по адресу: http://eprints.eemcs.utwente.nl/1077/ (есть ссылка на версию в формате PDF).

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

1. Используйте только аргументы функции, не используйте глобальное состояние.

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

Это может быть достигнуто с помощью простого c, без магии.

Предпосылкой для функционального стиля программирования является первоклассная функция. Это можно было бы смоделировать на портативном C, если вы допустите следующее:

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

/* 
 * with constraints desribed above we could have
 * good approximation of FP style in plain C
 */

int increment_int(int x) {
  return x + 1;
}

WRAP_PLAIN_FUNCTION_TO_FIRST_CLASS(increment, increment_int);

map(increment, list(number(0), number(1)); // --> list(1, 2)


/* composition of first class function is also possible */

function_t* computation = compose(
  increment,
  increment,
  increment
);

*(int*) call(computation, number(1)) == 4;

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

struct list_t {
  void* head;
  struct list_t* tail;
};

struct function_t {
   void* (*thunk)(list_t*);
   struct list_t* arguments;
}

void* apply(struct function_t* fn, struct list_t* arguments) {
  return fn->thunk(concat(fn->arguments, arguments));
}

/* expansion of WRAP_PLAIN_FUNCTION_TO_FIRST_CLASS */
void* increment_thunk(struct list_t* arguments) {
  int x_arg = *(int*) arguments->head;
  int value = increment_int(x_arg);
  int* number = malloc(sizeof *number);

  return number ? (*number = value, number) : NULL;
}

struct function_t* increment = &(struct function_t) {
  increment_thunk,
  NULL
};

/* call(increment, number(1)) expands to */
apply(increment, &(struct list_t) { number(1), NULL });

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

Способ, которым я занимался функциональным программированием на C, заключался в написании интерпретатора функционального языка на C. Я назвал его Fexl, что сокращенно от «Function EXpression Language».

Интерпретатор очень маленький, компилируется до 68 КБ в моей системе с включенным -O3. Это тоже не игрушка - я использую ее для всего нового производственного кода, который пишу для своего бизнеса (веб-учет для инвестиционных партнерств).

Теперь я пишу код на C только для того, чтобы (1) добавить встроенную функцию, вызывающую системную процедуру (например, fork, exec, setrlimit и т. д.), Или (2) оптимизировать функцию, которая в противном случае могла бы быть написана на Fexl (например, search для подстроки).

Механизм модуля основан на концепции «контекста». Контекст - это функция (написанная на Fexl), которая сопоставляет символ с его определением. Когда вы читаете файл Fexl, вы можете разрешить его с любым контекстом, который вам нравится. Это позволяет вам создавать собственные среды или запускать код в ограниченной «песочнице».

http://fexl.com