C'de fonksiyonel programlama için hangi araçlar var?

Son zamanlarda C ( değil C ++) fonksiyonel programlama yapmaya gitmek hakkında çok düşünüyordum . Açıkçası, C prosedürel bir dildir ve doğal olarak işlevsel programlamayı gerçekten desteklemez.

Dile bazı işlevsel programlama yapıları ekleyen herhangi bir derleyici / dil uzantısı var mı? GCC, dil uzantısı olarak iç içe geçmiş işlevler sağlar ; yuvalanmış işlevler üst yığın çerçevesinden değişkenlere erişebilir, ancak bu hala olgun kapanışlardan çok uzaktadır.

Örneğin, C'de gerçekten yararlı olabileceğini düşündüğüm bir şey, bir işlev işaretçisinin beklendiği her yerde, bir lambda ifadesini geçerek bir işlev işaretçisine çürüyen bir kapatma oluşturabileceğinizdir. C ++ 0x (harika olduğunu düşünüyorum) lambda ifadeleri içerecek; Ancak, düz C için geçerli araçlar arıyorum.

Açıklamak için, fonksiyonel programlama için daha uygun C belirli bir sorunu çözmeye çalışmıyorum; Bunu yapmak istersem sadece dışarıda hangi araçların olduğunu merak ediyorum.

FFCALL , C'de kapaklar oluşturmanıza olanak tanır - çağrıya eşdeğer callback = alloc_callback(&function, data)bir işlev işaretçisi döndürür . Bununla birlikte, çöp toplama işlemini elle halletmeniz gerekecektir.callback(arg1, ...)function(data, arg1, ...)

Buna bağlı olarak, Apple'ın GCC çatalına bloklar eklendi; bunlar işlev işaretçileri değildir, ancak yakalanan değişkenler için elle depolama ve depolama ihtiyacını ortadan kaldırırken lambdaların etrafından geçmenize izin verir (etkili, bazı sözdizimsel şeker ve çalışma zamanı kütüphanelerinin arkasına gizlenmiş bazı kopyalama ve referans sayımı gerçekleşir).

Lambda ifadelerini simüle etmek için GCC'nin iç içe geçmiş işlevlerini kullanabilirsiniz, aslında benim için yapacak bir makrom var:

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

Bunun gibi kullanın:

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

Fonksiyonel programlama lambdalarla değil, tamamen saf fonksiyonlarla ilgilidir. Yani aşağıdakiler genel olarak işlevsel stili teşvik eder:

1. Yalnızca işlev bağımsız değişkenlerini kullanın, genel durumu kullanmayın.

2. Yan etkileri azaltın, örneğin printf veya herhangi bir IO. Doğrudan tüm işlevlerde yan etkilere neden olmak yerine yürütülebilen G / Ç'yi tanımlayan verileri döndürün.

Bu düz c'de elde edilebilir, sihire gerek yoktur.

Hartel & Muller'in kitabı, Fonksiyonel C , günümüzde (2012-01-02) şu adreste bulunabilir: http://eprints.eemcs.utwente.nl/1077/ (PDF sürümüne bir bağlantı vardır).

Fonksiyonel programlama stili için ön koşul birinci sınıf bir fonksiyondur. Bir sonraki tahammül ederseniz, taşınabilir C'de simüle edilebilir:

• sözcüksel kapsam bağlarının elle yönetilmesi, aka kapanışları.
• fonksiyon değişkenlerinin ömür boyu manuel yönetimi.
• işlev uygulama / çağrısının alternatif sözdizimi.

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

böyle bir kod için çalışma zamanı aşağıdaki kadar küçük olabilir

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

Özünde, birinci sınıf işlevi, işlev / argüman çifti ve bir grup makro olarak temsil edilen kapaklarla taklit ediyoruz. Kodun tamamını burada bulabilirsiniz .

Akla gelen ana şey kod üreteçlerinin kullanılmasıdır. Fonksiyonel programlamayı sağlayan farklı bir dilde programlayıp daha sonra bundan C kodunu oluşturmak ister misiniz?

Bu çekici bir seçenek değilse, oradan yol almak için CPP'yi kötüye kullanabilirsiniz. Makro sistemi, bazı işlevsel programlama fikirlerini taklit etmenize izin vermelidir. Gcc'nin bu şekilde uygulandığını söyledim ama hiç kontrol etmedim.

C, elbette, fonksiyon işaretleyicilerini kullanarak fonksiyonları geçebilir, ana problemler kapanma eksikliğidir ve tip sistemi yoluna girme eğilimindedir. M4 gibi CPP'den daha güçlü makro sistemleri keşfedebilirsiniz. Nihayetinde, önerdiğim şey, gerçek C'nin büyük çaba sarf etmeden göreve gelmediğidir, ancak C'yi göreve uygun hale getirebilirsiniz. CPP kullanırsanız veya spektrumun diğer ucuna gidip başka bir dilden C kodu oluşturabilirseniz, bu uzantı en çok C'ye benzeyecektir.

Kapakları uygulamak istiyorsanız, montaj dili ve yığın takas / yönetimi ile uğraşmanız gerekir. Buna karşı tavsiye değil, sadece yapmanız gereken budur.

C'de anonim işlevleri nasıl ele alacağınızdan emin değilsiniz. Bir von Neumann makinesinde anonim işlevleri asm'de de yapabilirsiniz.

Hartel & Muller'in Fonksiyonel C kitabına bakın

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

Felix dil C ++ için derler. C ++ 'a aldırmazsanız belki de bu bir adım taşı olabilir.

Pek çok programlama dili C dilinde yazılmıştır. Ve bazıları birinci sınıf vatandaşlar olarak işlevleri desteklemektedir, o bölgedeki diller ecl (embbedabble common lisp IIRC), Gnu Smalltalk (gst) (Smalltalk blokları vardır), o zaman kütüphaneler var "kapanmalar" için örneğin glib2'de http://library.gnome.org/devel/gobject/unstable/chapter-signal.html#closure en azından işlevsel programlamaya içinde. Bu yüzden belki bu uygulamalardan bazılarını fonksiyonel programlama yapmak için kullanmak bir seçenek olabilir.

Eh ya da Ocaml, Haskell, Mozart / Oz veya benzeri ;-) öğrenmeye gidebilirsiniz.

Saygılarımızla

C'de fonksiyonel programlama yapmaya başladığım şekilde C'ye bir fonksiyonel dil tercümanı yazmaktı. Buna Fexl adını verdim.

Tercüman çok küçük, -O3 etkinken sistemimde 68K'ya kadar derleniyor. Bu bir oyuncak da değil - işim için yazdığım tüm yeni üretim kodları için kullanıyorum (yatırım ortaklıkları için web tabanlı muhasebe).

Şimdi C kodunu sadece (1) bir sistem rutini çağıran yerleşik bir işlev eklemek için yazıyorum (örneğin, fork, exec, setrlimit, vb.) Veya (2) Fexl'de yazılabilecek bir işlevi optimize etme (ör. Arama bir alt dize için).

Modül mekanizması bir "bağlam" kavramına dayanmaktadır. Bağlam, bir sembolü tanımıyla eşleyen bir işlevdir (Fexl ile yazılmış). Bir Fexl dosyasını okuduğunuzda, istediğiniz herhangi bir içerikle çözebilirsiniz. Bu, özel ortamlar oluşturmanıza veya kısıtlanmış bir "sanal alanda" kod çalıştırmanıza olanak tanır.

http://fexl.com

C ile ilgili işlevsel yapmak istediğiniz sözdizimi, sözdizimi veya anlambilim nedir? İşlevsel programlamanın anlambilimi kesinlikle C derleyicisine eklenebilir, ancak tamamlandığında, Şema, Haskell vb. Gibi mevcut işlevsel dillerden birine eşdeğer olacaksınız.

Doğrudan bu semantiği destekleyen sözdizimini öğrenmek daha iyi bir zaman olacaktır.

Objective-C'de bazı işlevsel özellikler olsa da, OSX'teki GCC bazı özellikleri de destekliyor, ancak yine de fonksiyonel bir dil kullanmaya başlamanızı tavsiye ederim, yukarıda belirtilen çok şey var. Şahsen şema ile başladım, Küçük Schemer gibi size yardımcı olabilecek bazı mükemmel kitaplar var.