Pemrograman Fungsional

Secara umum, bahasa pemrograman dapat dikelompokkan berdasarkan struktur pemrogramannya, terutama dalam mengimplementasikan suatu ekspresi. Jika setiap ekspresi selalu dinyatakan dalam bentuk fungsi, maka bahasa pemrograman ini disebut sebagai functional programming. Prinsip utama dari functional programming (FP) adalah bahwa nilai suatu ekspresi hanya tergantung kepada nilai sub-ekspresinya. Nilai ekspresi seperti a + b hanya tergantung kepada nilai a dan nilai b. Prinsip ini menghilangkan efek samping dalam ekspresi sehingga FP dapat disebut sebagai pemrograman tanpa assignment.

Bahasa fungsional pada umumnya, dan LISP pada khususnya, memainkan peranan penting dalam definisi bahasa. Sebuah definisi bahasa harus ditulis ke dalam notasinotasi, disebut meta-bahasa(meta-language) atau bahasa yang didefinisikan (defining language), dan bahasa yang didefinisikan cenderung menjadi fungsional. Dalam kenyataannya, implementasi LISP pertama dimulai, ketika LISP digunakan untuk mendefinisikan dirinya sendiri.
Konsep dasar FP berasal dari LISP. LISP dirancang oleh John McCarthy tahun 1958, mungkin LISP adalah bahasa tertua kedua, setelah fortran. Diyakini LISP sebagai penyedia pertama rekursi, kelas-utama fungsi, garbage collection, dan sebuah definisi 2 bahasa formal (dalam LISP itu sendiri). Implementasi LISP juga mendorong ke arah lingkungan pemrograman terintegrasi, yang menggabungkan editor, interpreter dan debugger.
LISP menggunakan notasi prefiks dengan tanda kurung. Jadi, aritmetika seperti 5 * 7 ditulis sebagai (* 5 7)
Contoh program sederhana dalam pemrograman List :
Misalkan kita ingin membuat fungsi untuk menentukan bilangan terbesar dari 2 buah bilangan. Maka program LIST nya adalah sebagai berikut :
(define (maks a b)
(if (> a b) a b
)
)
Berikut cara menjalankannya :
> (maks 5 6)
6
Contoh lain dengan menggunakan Scheme :
1. Menghitung jumlah suatu elemen dalam list
(define (hitung p q)
(if (null? q) 0
(if (equal? (modulo (car q) p) 0)
(+ 1 (hitung p (cdr q)))
(hitung p (cdr q))
)
)
)
Hasil compile :

2. Membentuk sebuah list dengan elemen dari 1 sampan i
(define (bentuk a)
(if (equal? a 0) null
(append (bentuk (- a 1)) (list a))
)
)
Hasil compile :

3. Memasukkan sebuah elemen ke dalam list
(define (insert p q r)
(if (equal? p 0)
(cons q r)
(cons (car r) (insert (- p 1) q (cdr r)))
)
)
hasil compile :

4. Mengambil semua elemen kecuali elemen terakhir
(define (ambil a)
(if (null? (cdr a)) null
(cons (car a) (ambil (cdr a)))
)
)
Hasil compile :

5. Menampilkan isi dari tiap elemen kecuali elemen pertama dan terakhir
(define (tengah a)
(if (null? (cddr a)) null
(cons (cadr a) (tengah (cdr a)))
)
)
Hasil compile :

6. Menghapus elemen yang memiliki nilai sama dengan sebelum/setelahnya dari sebuah list
(define (hapus a)
(if (null? a) null
(if (null? (cdr a)) a
(if (equal? (car a) (cadr a))
(hapus (cdr a))
(cons (car a) (hapus (cdr a)))
)
)
)
)
Hasil compile :

7. Menghitung jumlah elemen yang habis dibagi oleh suatu bilangan tertentu
(define (hitung a b)
(if (null? b) 0
(if (equal? (modulo (car b) a) 0)
(+ 1 (hitung a (cdr b)))
(hitung a (cdr b))
)
)
)
Hasil compile :

8. Menyisipkan sebuah elemen dengan posisi tertentu dalam sebuah list
(define (sisip a b c)
(if (equal? c 1)
(cons b a)
(cons (car a) (sisip (cdr a) b (- c 1)))
)
)
hasil compile :

9. Mencari nilai Faktor Persekutuan Terbesar (FPB)
(define (fpb b a)
(if (equal? a 0) b
(fpb a (modulo b a))
)
)
Hasil compile :

10. Menentukan digit paling depan dari suatu bilangan bulat
(define (depan a)
(if (number? a)
(if (< a 10) a
(depan (floor (/ a 10)))
)
0)
)
hasil compile :