Quali strumenti ci sono per la programmazione funzionale in C?

Ultimamente ho pensato molto a come fare la programmazione funzionale in C ( non C ++). Ovviamente, C è un linguaggio procedurale e non supporta realmente la programmazione funzionale in modo nativo.

Esistono estensioni di compilatore / linguaggio che aggiungono alcuni costrutti di programmazione funzionale al linguaggio? GCC fornisce funzioni nidificate come estensione del linguaggio; Le funzioni nidificate possono accedere alle variabili dal frame dello stack padre, ma questo è ancora molto lontano dalle chiusure mature.

Ad esempio, una cosa che penso possa essere davvero utile in C è che ovunque ci si aspetta un puntatore a funzione, si potrebbe essere in grado di passare un'espressione lambda, creando una chiusura che decade in un puntatore a funzione. C ++ 0x includerà espressioni lambda (che penso siano fantastiche); tuttavia, sto cercando strumenti applicabili alla scala C.

[Modifica] Per chiarire, non sto cercando di risolvere un particolare problema in C che sarebbe più adatto alla programmazione funzionale; Sono solo curioso di sapere quali strumenti ci sono là fuori se volessi farlo.

FFCALL ti consente di costruire chiusure in C - callback = alloc_callback(&function, data)restituisce un puntatore a funzione che callback(arg1, ...)equivale a chiamare function(data, arg1, ...). Dovrai comunque gestire manualmente la garbage collection.

Allo stesso modo, sono stati aggiunti blocchi al fork di GCC di Apple; non sono puntatori di funzioni, ma ti permettono di aggirare lambdas evitando la necessità di costruire e liberare manualmente le variabili catturate a mano (effettivamente, si verificano alcune copie e il conteggio dei riferimenti, nascosto dietro alcune librerie di zucchero sintattico e runtime).

Puoi usare le funzioni nidificate di GCC per simulare espressioni lambda, infatti, ho una macro per farlo per me:

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

Usa così:

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

La programmazione funzionale non riguarda le lambda, si tratta solo di funzioni pure. Pertanto, i seguenti promuovono ampiamente lo stile funzionale:

1. Usa solo argomenti di funzioni, non usare lo stato globale.

2. Ridurre al minimo gli effetti collaterali, ad esempio printf o qualsiasi IO. Restituisce i dati che descrivono IO che possono essere eseguiti invece di causare gli effetti collaterali direttamente in tutte le funzioni.

Questo può essere ottenuto in pianura, senza bisogno di magia.

Il libro di Hartel & Muller, Functional C , al giorno d'oggi (2012-01-02) è disponibile all'indirizzo: http://eprints.eemcs.utwente.nl/1077/ (esiste un collegamento alla versione PDF).

Prerequisito per lo stile di programmazione funzionale è una funzione di prima classe. Potrebbe essere simulato in C portatile se tolleri il prossimo:

• gestione manuale di attacchi di ambito lessicale, ovvero chiusure.
• gestione manuale della durata delle variabili funzione.
• sintassi alternativa della funzione application / call.

/* 
 * 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;

il tempo di esecuzione per tale codice potrebbe essere piccolo come quello di seguito

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 });

In sostanza imitiamo la funzione di prima classe con le chiusure rappresentate come coppia di funzioni / argomenti più un mucchio di macro. Il codice completo può essere trovato qui .

La cosa principale che viene in mente è l'uso di generatori di codice. Saresti disposto a programmare in un linguaggio diverso che ha fornito la programmazione funzionale e quindi generare il codice C da quello?

Se questa non è un'opzione interessante, allora potresti abusare di CPP per ottenere parte del percorso lì. Il sistema macro dovrebbe consentire di emulare alcune idee di programmazione funzionale. Ho sentito dire che gcc è implementato in questo modo ma non ho mai verificato.

C può ovviamente passare le funzioni usando i puntatori a funzione, i problemi principali sono la mancanza di chiusure e il sistema di tipi tende a mettersi in mezzo. Potresti esplorare sistemi macro più potenti di CPP come M4. Credo che alla fine, ciò che sto suggerendo è che la vera C non è all'altezza del compito senza grandi sforzi ma potresti estendere C per renderlo all'altezza del compito. Quell'estensione assomiglierebbe di più a C se usi CPP o potresti andare dall'altra parte dello spettro e generare codice C da qualche altra lingua.

Se si desidera implementare chiusure, è necessario diventare entusiasti con il linguaggio assembly e lo scambio / gestione dello stack. Non sconsigliarlo, solo dire che è quello che devi fare.

Non sono sicuro di come gestirai le funzioni anonime in C. Su una macchina von Neumann, però, potresti fare funzioni anonime in asm.

Guarda il libro di Hartel & Muller, Funzionale C

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

Il linguaggio Felix viene compilato in C ++. Forse potrebbe essere una pietra miliare, se non ti dispiace C ++.

Bene, alcuni linguaggi di programmazione sono scritti in C. E alcuni di essi supportano funzioni come cittadini di prima classe, le lingue in quella zona sono ecl (embriabble common lisp IIRC), Gnu Smalltalk (gst) (Smalltalk ha blocchi), quindi ci sono librerie per "chiusure" ad es. in glib2 http://library.gnome.org/devel/gobject/unstable/chapter-signal.html#closure che almeno si avvicina alla programmazione funzionale. Quindi forse usare alcune di queste implementazioni per eseguire la programmazione funzionale potrebbe essere un'opzione.

Bene o puoi andare ad imparare Ocaml, Haskell, Mozart / Oz o simili ;-)

Saluti

Il modo in cui ho fatto la programmazione funzionale in C è stato quello di scrivere un interprete di linguaggio funzionale in C. L'ho chiamato Fexl, che è l'abbreviazione di "Function EXpression Language".

L'interprete è molto piccolo, compilando fino a 68K sul mio sistema con -O3 abilitato. Non è nemmeno un giocattolo - lo sto usando per tutto il nuovo codice di produzione che scrivo per la mia attività (contabilità basata sul web per partnership di investimento).

Ora scrivo il codice C solo per (1) aggiungere una funzione integrata che chiama una routine di sistema (ad esempio fork, exec, setrlimit, ecc.), Oppure (2) ottimizzare una funzione che potrebbe altrimenti essere scritta in Fexl (ad es. Ricerca per una sottostringa).

Il meccanismo del modulo si basa sul concetto di "contesto". Un contesto è una funzione (scritta in Fexl) che associa un simbolo alla sua definizione. Quando leggi un file Fexl, puoi risolverlo con qualsiasi contesto ti piaccia. Ciò consente di creare ambienti personalizzati o eseguire codice in un "sandbox" limitato.

http://fexl.com

Cos'è che vuoi rendere funzionale, la sintassi o la semantica di C? La semantica della programmazione funzionale potrebbe certamente essere aggiunta al compilatore C, ma quando avessi finito, avresti essenzialmente l'equivalente di uno dei linguaggi funzionali esistenti, come Scheme, Haskell, ecc.

Sarebbe meglio usare il tempo per imparare la sintassi di quelle lingue che supportano direttamente quelle semantiche.

Non so di C. Ci sono alcune caratteristiche funzionali in Objective-C, GCC su OSX supporta anche alcune funzionalità, tuttavia consiglierei di nuovo di iniziare a usare un linguaggio funzionale, ce ne sono molte menzionate sopra. Ho iniziato personalmente con Schema, ci sono alcuni libri eccellenti come The Little Schemer che possono aiutarti a farlo.