LISP - Panduan Cepat

John McCarthy menemukan LISP pada tahun 1958, tak lama setelah pengembangan FORTRAN. Ini pertama kali diterapkan oleh Steve Russell pada komputer IBM 704.

Ini sangat cocok untuk program Artificial Intelligence, karena memproses informasi simbolik secara efektif.

Common Lisp berasal, selama 1980-an dan 1990-an, dalam upaya untuk menyatukan pekerjaan beberapa kelompok implementasi yang merupakan penerus Maclisp, seperti ZetaLisp dan NIL (Implementasi Baru Lisp) dll.

Ini berfungsi sebagai bahasa umum, yang dapat dengan mudah diperluas untuk implementasi tertentu.

Program yang ditulis dalam Common LISP tidak bergantung pada karakteristik khusus mesin, seperti panjang kata, dll.

Fitur LISP Umum

• Ini tidak bergantung pada mesin

• Ini menggunakan metodologi desain berulang, dan ekstensibilitas yang mudah.

• Ini memungkinkan memperbarui program secara dinamis.

• Ini menyediakan debugging tingkat tinggi.

• Ini menyediakan pemrograman berorientasi objek tingkat lanjut.

• Ini menyediakan sistem makro yang nyaman.

• Ini menyediakan tipe data yang luas seperti, objek, struktur, daftar, vektor, array yang dapat disesuaikan, tabel hash, dan simbol.

• Itu berbasis ekspresi.

• Ini menyediakan sistem kondisi berorientasi objek.

• Ini menyediakan perpustakaan I / O lengkap.

• Ini menyediakan struktur kontrol yang luas.

Aplikasi Dibangun di LISP

Aplikasi besar yang berhasil dibangun di Lisp.

• Emacs

• G2

• AutoCad

• Igor Engraver

• Yahoo Store

Pengaturan Lingkungan Lokal

Jika Anda masih ingin mengatur lingkungan Anda untuk bahasa pemrograman Lisp, Anda memerlukan dua perangkat lunak berikut yang tersedia di komputer Anda, (a) Text Editor dan (b) The Lisp Executer.

Editor Teks

Ini akan digunakan untuk mengetik program Anda. Contoh beberapa editor termasuk Windows Notepad, perintah OS Edit, Brief, Epsilon, EMACS, dan vim atau vi.

Nama dan versi editor teks dapat berbeda pada sistem operasi yang berbeda. Misalnya, Notepad akan digunakan di Windows, dan vim atau vi dapat digunakan di windows serta Linux atau UNIX.

File yang Anda buat dengan editor Anda disebut file sumber dan berisi kode sumber program. File sumber untuk program Lisp biasanya dinamai dengan ekstensi ".lisp".

Sebelum memulai pemrograman Anda, pastikan Anda memiliki satu editor teks dan Anda memiliki pengalaman yang cukup untuk menulis program komputer, simpan dalam sebuah file, akhirnya jalankan.

Pelaksana Lisp

Kode sumber yang ditulis dalam file sumber adalah sumber yang dapat dibaca manusia untuk program Anda. Ini perlu "dieksekusi", untuk berubah menjadi bahasa mesin sehingga CPU Anda benar-benar dapat menjalankan program sesuai instruksi yang diberikan.

Bahasa pemrograman Lisp ini akan digunakan untuk mengeksekusi kode sumber Anda ke dalam program eksekusi akhir. Saya berasumsi Anda memiliki pengetahuan dasar tentang bahasa pemrograman.

CLISP adalah kompiler multi-arsitektur GNU Common LISP yang digunakan untuk menyiapkan LISP di Windows. Versi windows mengemulasi lingkungan unix menggunakan MingW di bawah windows. Penginstal menangani ini dan secara otomatis menambahkan clisp ke variabel PATH windows.

Anda bisa mendapatkan CLISP terbaru untuk Windows dari sini - https://sourceforge.net/projects/clisp/files/latest/download

Ini membuat pintasan di Start Menu secara default, untuk penerjemah baris demi baris.

Cara menggunakan CLISP

Selama instalasi, clisp secara otomatis ditambahkan ke variabel PATH Anda jika Anda memilih opsi (DIREKOMENDASIKAN) Ini berarti Anda cukup membuka jendela Command Prompt baru dan mengetik "clisp" untuk membuka kompiler.

Untuk menjalankan file * .lisp atau * .lsp, cukup gunakan -

clisp hello.lisp

Ekspresi LISP disebut ekspresi simbolik atau ekspresi-s. Ekspresi s terdiri dari tiga objek, atom, daftar, dan string yang valid.

Setiap ekspresi-s adalah program yang valid.

Program LISP berjalan baik di file interpreter atau sebagai compiled code.

Penerjemah memeriksa kode sumber dalam pengulangan berulang, yang juga disebut loop baca-evaluasi-cetak (REPL). Ia membaca kode program, mengevaluasinya, dan mencetak nilai yang dikembalikan oleh program.

Program Sederhana

Mari kita tulis ekspresi-s untuk menemukan jumlah dari tiga angka 7, 9 dan 11. Untuk melakukan ini, kita dapat mengetik di prompt interpreter.

(+ 7 9 11)

LISP mengembalikan hasil -

27

Jika Anda ingin menjalankan program yang sama dengan kode yang telah dikompilasi, buat file kode sumber LISP bernama myprog.lisp dan ketikkan kode berikut di dalamnya.

(write (+ 7 9 11))

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP langsung menjalankannya dan hasil yang dikembalikan adalah -

27

LISP Menggunakan Notasi Awalan

Anda mungkin telah mencatat bahwa LISP menggunakan prefix notation.

Pada program di atas simbol + berfungsi sebagai nama fungsi untuk proses penjumlahan bilangan.

Dalam notasi prefiks, operator ditulis sebelum operannya. Misalnya ekspresi,

a * ( b + c ) / d

akan ditulis sebagai -

(/ (* a (+ b c) ) d)

Mari kita ambil contoh lain, mari kita tulis kode untuk mengubah suhu Fahrenheit dari 60 ^o F ke skala celcius -

Ekspresi matematika untuk konversi ini adalah -

(60 * 9 / 5) + 32

Buat file kode sumber bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write(+ (* (/ 9 5) 60) 32))

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP mengeksekusinya dengan segera dan hasil yang dikembalikan adalah-

140

Evaluasi Program LISP

Evaluasi program LISP memiliki dua bagian -

• Terjemahan teks program menjadi objek Lisp oleh program pembaca

• Implementasi semantik bahasa dalam hal objek ini oleh program evaluator

Proses evaluasi mengambil langkah-langkah berikut -

• Pembaca menerjemahkan string karakter ke objek LISP atau s-expressions.

• Evaluator mendefinisikan sintaks Lisp formsyang dibangun dari ekspresi-s. Evaluasi tingkat kedua ini mendefinisikan sintaks yang menentukans-expressions adalah bentuk LISP.

• Evaluator bekerja sebagai fungsi yang menggunakan formulir LISP yang valid sebagai argumen dan mengembalikan nilai. Inilah alasan mengapa kami meletakkan ekspresi LISP dalam tanda kurung, karena kami mengirimkan seluruh ekspresi / formulir ke evaluator sebagai argumen.

Program 'Halo Dunia'

Mempelajari bahasa pemrograman baru tidak benar-benar berhasil sampai Anda belajar bagaimana menyapa seluruh dunia dalam bahasa itu, kan!

Jadi, silahkan buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write-line "Hello World")

(write-line "I am at 'Tutorials Point'! Learning LISP")

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP langsung menjalankannya dan hasil yang dikembalikan adalah -

Hello World

I am at 'Tutorials Point'! Learning LISP

Building Block Dasar di LISP

Program LISP terdiri dari tiga blok bangunan dasar -

• atom
• list
• string

Sebuah atomadalah angka atau string karakter yang berdekatan. Ini termasuk angka dan karakter khusus.

Berikut adalah contoh beberapa atom yang valid -

hello-from-tutorials-point
name
123008907
*hello*
Block#221
abc123

SEBUAH list adalah urutan atom dan / atau daftar lain yang diapit tanda kurung.

Berikut adalah contoh dari beberapa daftar yang valid -

( i am a list)
(a ( a b c) d e fgh)
(father tom ( susan bill joe))
(sun mon tue wed thur fri sat)
( )

SEBUAH string adalah sekelompok karakter yang diapit oleh tanda kutip ganda.

Berikut adalah contoh beberapa string yang valid -

" I am a string"
"a ba c d efg #$%^&!"
"Please enter the following details :"
"Hello from 'Tutorials Point'! "

Menambahkan Komentar

Simbol titik koma (;) digunakan untuk menunjukkan baris komentar.

Sebagai contoh,

(write-line "Hello World") ; greet the world

; tell them your whereabouts

(write-line "I am at 'Tutorials Point'! Learning LISP")

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP langsung menjalankannya dan hasil yang dikembalikan adalah -

Hello World

I am at 'Tutorials Point'! Learning LISP

Beberapa Poin Penting sebelum Pindah ke Berikutnya

Berikut adalah beberapa poin penting yang perlu diperhatikan -

• Operasi numerik dasar di LISP adalah +, -, *, dan /

• LISP merepresentasikan pemanggilan fungsi f (x) sebagai (fx), misalnya cos (45) dituliskan sebagai cos 45

• Ekspresi LISP peka huruf besar kecil, cos 45 atau COS 45 sama.

• LISP mencoba mengevaluasi semuanya, termasuk argumen suatu fungsi. Hanya tiga jenis elemen yang merupakan konstanta dan selalu mengembalikan nilainya sendiri

  • Numbers

  • Surat t, itu singkatan dari kebenaran logis.

  • Nilai nil, yang berarti salah logis, serta daftar kosong.

Sedikit Lebih Banyak tentang Formulir LISP

Pada bab sebelumnya, telah disebutkan bahwa proses evaluasi kode LISP mengambil langkah-langkah sebagai berikut.

• Pembaca menerjemahkan string karakter ke objek LISP atau s-expressions.

• Evaluator mendefinisikan sintaks Lisp formsyang dibangun dari ekspresi-s. Evaluasi tingkat kedua ini mendefinisikan sintaks yang menentukan ekspresi-s mana yang merupakan bentuk LISP.

Sekarang, formulir LISP bisa.

• Sebuah Atom
• Kosong atau non-daftar
• Daftar apa pun yang memiliki simbol sebagai elemen pertamanya

Evaluator bekerja sebagai fungsi yang menggunakan formulir LISP yang valid sebagai argumen dan mengembalikan nilai. Inilah alasan mengapa kami menempatkan fileLISP expression in parenthesis, karena kami mengirimkan seluruh ekspresi / formulir ke evaluator sebagai argumen.

Konvensi Penamaan di LISP

Nama atau simbol dapat terdiri dari sejumlah karakter alfanumerik selain spasi, tanda kurung buka dan tutup, tanda kutip ganda dan tunggal, garis miring terbalik, koma, titik dua, titik koma, dan batang vertikal. Untuk menggunakan karakter ini dalam nama, Anda perlu menggunakan karakter escape (\).

Sebuah nama dapat terdiri dari angka tetapi tidak seluruhnya terdiri dari angka, karena dengan demikian akan dibaca sebagai angka. Demikian pula sebuah nama dapat memiliki titik, tetapi tidak dapat seluruhnya terdiri dari titik.

Penggunaan Tanda Kutip Tunggal

LISP mengevaluasi semuanya termasuk argumen fungsi dan anggota daftar.

Terkadang, kita perlu memahami atom atau daftar secara harfiah dan tidak ingin mereka dievaluasi atau diperlakukan sebagai pemanggilan fungsi.

Untuk melakukan ini, kita perlu mengawali atom atau list dengan satu tanda kutip.

Contoh berikut menunjukkan hal ini.

Buat file bernama main.lisp dan ketikkan kode berikut ke dalamnya.

(write-line "single quote used, it inhibits evaluation")
(write '(* 2 3))
(write-line " ")
(write-line "single quote not used, so expression evaluated")
(write (* 2 3))

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP langsung menjalankannya dan hasil yang dikembalikan adalah -

single quote used, it inhibits evaluation
(* 2 3) 
single quote not used, so expression evaluated
6

Di LISP, variabel tidak diketik, tetapi objek data diketik.

Tipe data LISP dapat dikategorikan sebagai.

• Scalar types - misalnya, jenis angka, karakter, simbol, dll.

• Data structures - misalnya, daftar, vektor, bit-vektor, dan string.

Variabel apa pun dapat mengambil objek LISP apa pun sebagai nilainya, kecuali Anda telah mendeklarasikannya secara eksplisit.

Meskipun, tidak perlu untuk menentukan tipe data untuk variabel LISP, bagaimanapun, ini membantu dalam ekspansi loop tertentu, dalam deklarasi metode dan beberapa situasi lain yang akan kita bahas di bab selanjutnya.

Tipe data disusun menjadi hierarki. Tipe data adalah sekumpulan objek LISP dan banyak objek mungkin termasuk dalam satu set tersebut.

Itu typep predikat digunakan untuk menemukan apakah suatu objek termasuk dalam tipe tertentu.

Itu type-of fungsi mengembalikan tipe data dari objek tertentu.

Ketik Penentu di LISP

Penentu tipe adalah simbol yang ditentukan sistem untuk tipe data.

Himpunan	fixnum	paket	string sederhana
atom	mengapung	pathname	sederhana-vektor
bignum	fungsi	keadaan acak	pelampung tunggal
sedikit	tabel hash	perbandingan	standar-char
bit-vektor	bilangan bulat	rasional	aliran
karakter	kata kunci	dapat dibaca	tali
[umum]	daftar	urutan	[string-char]
compiled-function	pelampung panjang	pelampung pendek	simbol
kompleks	nihil	byte bertanda tangan	t
kontra	batal	array sederhana	unsigned-byte
mengapung ganda	jumlah	vektor-bit-sederhana	vektor

Selain tipe yang ditentukan sistem ini, Anda dapat membuat tipe data Anda sendiri. Ketika tipe struktur ditentukan menggunakandefstruct fungsi, nama tipe struktur menjadi simbol tipe yang valid.

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq x 10)
(setq y 34.567)
(setq ch nil)
(setq n 123.78)
(setq bg 11.0e+4)
(setq r 124/2)

(print x)
(print y)
(print n)
(print ch)
(print bg)
(print r)

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP langsung menjalankannya dan hasil yang dikembalikan adalah -

10 
34.567 
123.78 
NIL 
110000.0 
62

Contoh 2

Selanjutnya mari kita periksa jenis variabel yang digunakan pada contoh sebelumnya. Buat file kode sumber baru bernama main. cadel dan ketik kode berikut di dalamnya.

(defvar x 10)
(defvar y 34.567)
(defvar ch nil)
(defvar n 123.78)
(defvar bg 11.0e+4)
(defvar r 124/2)

(print (type-of x))
(print (type-of y))
(print (type-of n))
(print (type-of ch))
(print (type-of bg))
(print (type-of r))

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP langsung menjalankannya dan hasil yang dikembalikan adalah -

(INTEGER 0 281474976710655) 
SINGLE-FLOAT 
SINGLE-FLOAT 
NULL 
SINGLE-FLOAT 
(INTEGER 0 281474976710655)

Makro memungkinkan Anda memperluas sintaks LISP standar.

Secara teknis, makro adalah fungsi yang menggunakan ekspresi s sebagai argumen dan mengembalikan bentuk LISP, yang kemudian dievaluasi.

Mendefinisikan Makro

Di LISP, makro bernama ditentukan menggunakan makro lain bernama defmacro. Sintaks untuk mendefinisikan makro adalah -

(defmacro macro-name (parameter-list))
"Optional documentation string."
body-form

Definisi makro terdiri dari nama makro, daftar parameter, string dokumentasi opsional, dan badan ekspresi Lisp yang menentukan pekerjaan yang akan dilakukan oleh makro.

Contoh

Mari kita tulis makro sederhana bernama setTo10, yang akan mengambil angka dan menyetel nilainya menjadi 10.

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defmacro setTo10(num)
(setq num 10)(print num))
(setq x 25)
(print x)
(setTo10 x)

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP langsung menjalankannya dan hasil yang dikembalikan adalah -

25
10

Dalam LISP, setiap variabel diwakili oleh a symbol. Nama variabel adalah nama simbol dan disimpan di sel penyimpanan simbol.

Variabel Global

Variabel global memiliki nilai permanen di seluruh sistem LISP dan tetap berlaku sampai nilai baru ditentukan.

Variabel global umumnya dideklarasikan menggunakan defvar membangun.

Sebagai contoh

(defvar x 234)
(write x)

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP segera menjalankannya dan hasil yang dikembalikan adalah

234

Karena tidak ada deklarasi tipe untuk variabel di LISP, Anda secara langsung menentukan nilai untuk simbol dengan setq membangun.

Sebagai contoh

->(setq x 10)

Ekspresi di atas memberikan nilai 10 ke variabel x. Anda dapat merujuk ke variabel menggunakan simbol itu sendiri sebagai ekspresi.

Itu symbol-value fungsi memungkinkan Anda untuk mengekstrak nilai yang disimpan di tempat penyimpanan simbol.

Sebagai contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq x 10)
(setq y 20)
(format t "x = ~2d y = ~2d ~%" x y)

(setq x 100)
(setq y 200)
(format t "x = ~2d y = ~2d" x y)

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP segera menjalankannya dan hasil yang dikembalikan adalah.

x = 10 y = 20 
x = 100 y = 200

Variabel Lokal

Variabel lokal didefinisikan dalam prosedur tertentu. Parameter yang dinamai sebagai argumen dalam definisi fungsi juga merupakan variabel lokal. Variabel lokal hanya dapat diakses di dalam fungsi masing-masing.

Seperti variabel global, variabel lokal juga dapat dibuat menggunakan setq membangun.

Ada dua konstruksi lainnya - let dan prog untuk membuat variabel lokal.

Konstruksi let memiliki sintaks berikut.

(let ((var1  val1) (var2  val2).. (varn  valn))<s-expressions>)

Di mana var1, var2, ..varn adalah nama variabel dan val1, val2, .. valn adalah nilai awal yang ditetapkan ke masing-masing variabel.

Kapan letdijalankan, setiap variabel diberi nilai masing-masing dan terakhir ekspresi s dievaluasi. Nilai ekspresi terakhir yang dievaluasi dikembalikan.

Jika Anda tidak menyertakan nilai awal untuk variabel, itu ditetapkan ke nil.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(let ((x 'a) (y 'b)(z 'c))
(format t "x = ~a y = ~a z = ~a" x y z))

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP segera menjalankannya dan hasil yang dikembalikan adalah.

x = A y = B z = C

Itu prog konstruk juga memiliki daftar variabel lokal sebagai argumen pertamanya, yang diikuti oleh tubuh dari prog, dan sejumlah ekspresi-s.

Itu prog function mengeksekusi daftar s-ekspresi secara berurutan dan mengembalikan nihil kecuali jika menemukan panggilan fungsi bernama return. Kemudian argumen dari return fungsi dievaluasi dan dikembalikan.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(prog ((x '(a b c))(y '(1 2 3))(z '(p q 10)))
(format t "x = ~a y = ~a z = ~a" x y z))

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP segera menjalankannya dan hasil yang dikembalikan adalah.

x = (A B C) y = (1 2 3) z = (P Q 10)

Dalam LISP, konstanta adalah variabel yang tidak pernah berubah nilainya selama eksekusi program. Konstanta dideklarasikan menggunakandefconstant membangun.

Contoh

Contoh berikut menunjukkan mendeklarasikan PI konstanta global dan kemudian menggunakan nilai ini di dalam fungsi bernama area-circle yang menghitung luas lingkaran.

Itu defun konstruk digunakan untuk mendefinisikan suatu fungsi, kita akan memeriksanya di Functions bab.

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defconstant PI 3.141592)
(defun area-circle(rad)
   (terpri)
   (format t "Radius: ~5f" rad)
   (format t "~%Area: ~10f" (* PI rad rad)))
(area-circle 10)

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP segera menjalankannya dan hasil yang dikembalikan adalah.

Radius:  10.0
Area:   314.1592

Operator adalah simbol yang memberi tahu kompiler untuk melakukan manipulasi matematika atau logika tertentu. LISP memungkinkan berbagai operasi pada data, didukung oleh berbagai fungsi, makro, dan konstruksi lainnya.

Operasi yang diizinkan pada data dapat dikategorikan sebagai -

• Operasi Aritmatika
• Operasi Perbandingan
• Operasi Logis
• Operasi Bitwise

Operasi Aritmatika

Tabel berikut menunjukkan semua operator aritmatika yang didukung oleh LISP. Asumsikan variabelA memegang 10 dan variabel B memegang 20 lalu -

Show Examples

Operator	Deskripsi	Contoh
+	Menambahkan dua operan	(+ AB) akan memberi 30
-	Mengurangi operan kedua dari yang pertama	(- AB) akan memberikan -10
*	Menggandakan kedua operan	(* AB) akan memberikan 200
/	Membagi pembilang dengan de-numerator	(/ BA) akan memberikan 2
mod, rem	Modulus Operator dan sisa setelah pembagian integer	(mod BA) akan memberikan 0
incf	Operator increments meningkatkan nilai integer dengan argumen kedua yang ditentukan	(incf A 3) akan memberikan 13
decf	Operator pengurangan menurunkan nilai integer dengan argumen kedua yang ditentukan	(decf A 4) akan memberikan 9

Operasi Perbandingan

Tabel berikut menunjukkan semua operator relasional yang didukung oleh LISP yang membandingkan antar angka. Namun tidak seperti operator relasional dalam bahasa lain, operator perbandingan LISP mungkin memerlukan lebih dari dua operan dan hanya bekerja pada angka.

Asumsikan variabel A memegang 10 dan variabel B memegang 20, lalu -

Show Examples

Operator	Deskripsi	Contoh
=	Memeriksa apakah nilai operan semua sama atau tidak, jika ya maka kondisi menjadi benar.	(= AB) tidak benar.
/ =	Memeriksa apakah nilai operan semua berbeda atau tidak, jika nilai tidak sama maka kondisi menjadi benar.	(/ = AB) benar.
>	Memeriksa apakah nilai operan menurun secara monoton.	(> AB) tidak benar.
<	Memeriksa apakah nilai operan meningkat secara monoton.	(<AB) benar.
> =	Memeriksa apakah nilai setiap operan kiri lebih besar dari atau sama dengan nilai operan kanan berikutnya, jika ya maka kondisi menjadi benar.	(> = AB) tidak benar.
<=	Memeriksa apakah nilai operan kiri kurang dari atau sama dengan nilai operan kanannya, jika ya maka kondisi menjadi benar.	(<= AB) benar.
maks	Ini membandingkan dua atau lebih argumen dan mengembalikan nilai maksimum.	(max AB) mengembalikan 20
min	Ini membandingkan dua atau lebih argumen dan mengembalikan nilai minimum.	(min AB) mengembalikan 10

Operasi Logis pada Nilai Boolean

LISP umum menyediakan tiga operator logika: and, or, dan notyang beroperasi pada nilai Boolean. MenganggapA memiliki nilai nihil dan B memiliki nilai 5, lalu -

Show Examples

Operator	Deskripsi	Contoh
dan	Ini membutuhkan sejumlah argumen. Argumen dievaluasi dari kiri ke kanan. Jika semua argumen bernilai bukan nil, maka nilai argumen terakhir dikembalikan. Jika tidak, nihil dikembalikan.	(dan AB) akan mengembalikan NIL.
atau	Ini membutuhkan sejumlah argumen. Argumen dievaluasi dari kiri ke kanan sampai satu mengevaluasi ke non-nil, dalam kasus seperti nilai argumen dikembalikan, jika tidak maka akan dikembalikannil.	(atau AB) akan mengembalikan 5.
tidak	Dibutuhkan satu argumen dan kembali t jika argumen bernilai nil.	(bukan A) akan mengembalikan T.

Operasi Bitwise pada Bilangan

Operator bitwise bekerja pada bit dan melakukan operasi bit demi bit. Tabel kebenaran untuk operasi bitwise dan, atau, dan xor adalah sebagai berikut -

Show Examples

p	q	p dan q	p atau q	p xor q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assume if A = 60; and B = 13; now in binary format they will be as follows:
A = 0011 1100
B = 0000 1101
-----------------
A and B = 0000 1100
A or B = 0011 1101
A xor B = 0011 0001
not A  = 1100 0011

Operator Bitwise yang didukung oleh LISP tercantum dalam tabel berikut. Asumsikan variabelA memegang 60 dan variabel B memegang 13, lalu -

Operator	Deskripsi	Contoh
logand	Ini mengembalikan logika AND yang bijak dari argumennya. Jika tidak ada argumen yang diberikan, maka hasilnya adalah -1, yang merupakan identitas untuk operasi ini.	(logand ab)) akan memberikan 12
logior	Ini mengembalikan logika INCLUSIVE OR bit-bijaksana dari argumennya. Jika tidak ada argumen yang diberikan, maka hasilnya nol, yang merupakan identitas untuk operasi ini.	(logior ab) akan menghasilkan 61
logxor	Ini mengembalikan logika EXCLUSIVE OR bit-bijaksana dari argumennya. Jika tidak ada argumen yang diberikan, maka hasilnya nol, yang merupakan identitas untuk operasi ini.	(logxor ab) akan menghasilkan 49
lognor	Ini mengembalikan bit bijaksana dari argumennya. Jika tidak ada argumen yang diberikan, maka hasilnya adalah -1, yang merupakan identitas untuk operasi ini.	(lognor ab) akan memberikan -62,
logeqv	Ini mengembalikan EQUIVALENCE logis bit-bijaksana (juga dikenal sebagai eksklusif nor) dari argumennya. Jika tidak ada argumen yang diberikan, maka hasilnya adalah -1, yang merupakan identitas untuk operasi ini.	(logeqv ab) akan memberikan -50

Struktur pengambilan keputusan mengharuskan pemrogram menentukan satu atau lebih kondisi untuk dievaluasi atau diuji oleh program, bersama dengan pernyataan atau pernyataan yang akan dieksekusi jika kondisi ditentukan benar, dan secara opsional, pernyataan lain akan dijalankan jika kondisinya ditentukan sebagai salah.

Berikut ini adalah bentuk umum dari struktur pengambilan keputusan khas yang ditemukan di sebagian besar bahasa pemrograman -

LISP menyediakan jenis konstruksi pengambilan keputusan berikut. Klik tautan berikut untuk memeriksa detailnya.

Sr.No.	Konstruksi & Deskripsi
1	kond Konstruksi ini digunakan untuk digunakan untuk memeriksa beberapa klausa tindakan uji. Ini dapat dibandingkan dengan pernyataan if bersarang dalam bahasa pemrograman lain.
2	jika Konstruk if memiliki berbagai bentuk. Dalam bentuk yang paling sederhana, ini diikuti oleh klausa pengujian, tindakan pengujian, dan beberapa tindakan konsekuensi lainnya. Jika klausa pengujian bernilai true, maka tindakan pengujian dijalankan sebaliknya, klausa konsekuensi dievaluasi.
3	kapan Dalam bentuk yang paling sederhana, ini diikuti oleh klausa pengujian, dan tindakan pengujian. Jika klausa pengujian bernilai true, maka tindakan pengujian dijalankan sebaliknya, klausa konsekuensi dievaluasi.
4	kasus Konstruksi ini mengimplementasikan beberapa klausa aksi uji seperti konstruksi cond. Namun, ini mengevaluasi formulir kunci dan memungkinkan beberapa klausul tindakan berdasarkan evaluasi formulir kunci tersebut.

Mungkin ada situasi ketika Anda perlu mengeksekusi sekumpulan kode berkali-kali. Pernyataan loop memungkinkan kita untuk mengeksekusi pernyataan atau sekelompok pernyataan beberapa kali dan berikut ini adalah bentuk umum dari pernyataan loop di sebagian besar bahasa pemrograman.

LISP menyediakan jenis konstruksi berikut untuk menangani persyaratan perulangan. Klik tautan berikut untuk memeriksa detailnya.

Sr.No.	Konstruksi & Deskripsi
1	lingkaran Itu loopkonstruk adalah bentuk iterasi paling sederhana yang disediakan oleh LISP. Dalam bentuknya yang paling sederhana, ini memungkinkan Anda untuk mengeksekusi beberapa pernyataan berulang kali hingga menemukan areturn pernyataan.
2	loop untuk Loop for construct memungkinkan Anda mengimplementasikan for-loop seperti iterasi seperti yang paling umum dalam bahasa lain.
3	melakukan Konstruksi do juga digunakan untuk melakukan iterasi menggunakan LISP. Ini memberikan bentuk iterasi yang terstruktur.
4	dotimes Konstruksi dotimes memungkinkan perulangan untuk beberapa jumlah iterasi tetap.
5	lumba-lumba Konstruksi dolist memungkinkan iterasi melalui setiap elemen daftar.

Keluar Dengan Anggun Dari Blok

Itu block dan return-from memungkinkan Anda untuk keluar dengan anggun dari blok bersarang jika terjadi kesalahan.

Itu blockfunction memungkinkan Anda untuk membuat blok bernama dengan tubuh yang terdiri dari nol atau lebih pernyataan. Sintaksnya adalah -

(block block-name(
...
...
))

Itu return-from function mengambil nama blok dan nilai kembalian opsional (default-nya adalah nil).

Contoh berikut menunjukkan ini -

Contoh

Buat file kode sumber baru bernama main.lisp dan ketik kode berikut di dalamnya -

(defun demo-function (flag)
   (print 'entering-outer-block)
   
   (block outer-block
      (print 'entering-inner-block)
      (print (block inner-block

         (if flag
            (return-from outer-block 3)
            (return-from inner-block 5)
         )

         (print 'This-wil--not-be-printed))
      )

      (print 'left-inner-block)
      (print 'leaving-outer-block)
   t)
)
(demo-function t)
(terpri)
(demo-function nil)

Ketika Anda mengklik tombol Execute, atau mengetik Ctrl + E, LISP langsung menjalankannya dan hasil yang dikembalikan adalah -

ENTERING-OUTER-BLOCK 
ENTERING-INNER-BLOCK 

ENTERING-OUTER-BLOCK 
ENTERING-INNER-BLOCK 
5 
LEFT-INNER-BLOCK 
LEAVING-OUTER-BLOCK

Fungsi adalah sekelompok pernyataan yang bersama-sama melakukan tugas.

Anda dapat membagi kode Anda menjadi beberapa fungsi terpisah. Bagaimana Anda membagi kode Anda di antara fungsi yang berbeda terserah Anda, tetapi secara logis pembagian biasanya begitu setiap fungsi melakukan tugas tertentu.

Mendefinisikan Fungsi di LISP

Makro bernama defundigunakan untuk mendefinisikan fungsi. Itudefun makro membutuhkan tiga argumen -

• Nama fungsinya
• Parameter fungsi
• Tubuh fungsinya

Sintaks untuk defun adalah -

(defun name (parameter-list) "Optional documentation string." body)

Mari kita gambarkan konsep tersebut dengan contoh sederhana.

Contoh 1

Mari kita tulis sebuah fungsi bernama averagenum yang akan mencetak rata-rata empat angka. Kami akan mengirimkan nomor-nomor ini sebagai parameter.

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defun averagenum (n1 n2 n3 n4)
   (/ ( + n1 n2 n3 n4) 4)
)
(write(averagenum 10 20 30 40))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

25

Contoh 2

Mari kita definisikan dan panggil fungsi yang akan menghitung luas lingkaran ketika jari-jari lingkaran diberikan sebagai argumen.

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defun area-circle(rad)
   "Calculates area of a circle with given radius"
   (terpri)
   (format t "Radius: ~5f" rad)
   (format t "~%Area: ~10f" (* 3.141592 rad rad))
)
(area-circle 10)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Radius:  10.0
Area:   314.1592

Harap dicatat bahwa -

• Anda dapat memberikan daftar kosong sebagai parameter, yang berarti fungsi tersebut tidak memerlukan argumen, daftar kosong, ditulis sebagai ().

• LISP juga memungkinkan argumen opsional, multipel, dan kata kunci.

• String dokumentasi menjelaskan tujuan dari fungsi tersebut. Ini terkait dengan nama fungsi dan dapat diperoleh dengan menggunakandocumentation fungsi.

• Badan fungsi dapat terdiri dari sejumlah ekspresi Lisp.

• Nilai ekspresi terakhir dalam body dikembalikan sebagai nilai fungsinya.

• Anda juga dapat mengembalikan nilai dari fungsi menggunakan return-from operator khusus.

Mari kita bahas konsep di atas secara singkat. Klik tautan berikut untuk menemukan detailnya -

• Parameter Opsional

• Parameter Istirahat

• Parameter Kata Kunci

• Mengembalikan Nilai dari suatu Fungsi

• Fungsi Lambda

• Fungsi Pemetaan

Predikat adalah fungsi yang menguji argumennya untuk beberapa kondisi tertentu dan mengembalikan nihil jika kondisinya salah, atau beberapa nilai bukan nil adalah kondisinya benar.

Tabel berikut menunjukkan beberapa predikat yang paling umum digunakan -

Sr.No.	Predikat & Deskripsi
1	atom Dibutuhkan satu argumen dan mengembalikan t jika argumennya adalah atom atau nil jika sebaliknya.
2	equal Dibutuhkan dua argumen dan hasil t jika mereka secara struktural sama atau nil jika tidak.
3	eq Dibutuhkan dua argumen dan hasil t jika mereka adalah objek identik yang sama, berbagi lokasi memori yang sama atau nil jika tidak.
4	eql Dibutuhkan dua argumen dan hasil t jika argumennya eq, atau jika mereka adalah bilangan dari tipe yang sama dengan nilai yang sama, atau jika mereka adalah objek karakter yang mewakili karakter yang sama, atau nil jika tidak.
5	evenp Dibutuhkan satu argumen numerik dan kembali t jika argumennya bilangan genap atau nil jika sebaliknya.
6	oddp Dibutuhkan satu argumen numerik dan kembali t jika argumennya bilangan ganjil atau nil jika sebaliknya.
7	zerop Dibutuhkan satu argumen numerik dan kembali t jika argumennya nol atau nil jika sebaliknya.
8	null Dibutuhkan satu argumen dan kembali t jika argumen bernilai nol, jika tidak maka akan dikembalikan nil.
9	listp Dibutuhkan satu argumen dan kembali t jika argumen dievaluasi ke daftar jika tidak maka akan dikembalikan nil.
10	greaterp Dibutuhkan satu atau lebih argumen dan hasil t jika ada argumen tunggal atau argumen tersebut berturut-turut lebih besar dari kiri ke kanan, atau nil jika sebaliknya.
11	lessp Dibutuhkan satu atau lebih argumen dan hasil t jika ada satu argumen atau argumen secara berturut-turut lebih kecil dari kiri ke kanan, atau nil jika sebaliknya.
12	numberp Dibutuhkan satu argumen dan kembali t jika argumennya adalah angka atau nil jika sebaliknya.
13	symbolp Dibutuhkan satu argumen dan kembali t jika argumennya adalah simbol jika tidak maka akan dikembalikan nil.
14	integerp Dibutuhkan satu argumen dan kembali t jika argumennya adalah integer jika tidak maka akan dikembalikan nil.
15	rationalp Dibutuhkan satu argumen dan kembali t jika argumennya adalah bilangan rasional, baik rasio atau bilangan, jika tidak maka akan dikembalikan nil.
16	floatp Dibutuhkan satu argumen dan kembali t jika argumennya adalah angka floating point jika tidak maka akan dikembalikan nil.
17	realp Dibutuhkan satu argumen dan kembali t jika argumennya adalah bilangan real jika tidak maka akan dikembalikan nil.
18	complexp Dibutuhkan satu argumen dan kembali t jika argumennya adalah bilangan kompleks jika tidak maka akan dikembalikan nil.
19	characterp Dibutuhkan satu argumen dan kembali t jika argumennya adalah karakter jika tidak maka akan dikembalikan nil.
20	stringp Dibutuhkan satu argumen dan kembali t jika argumen adalah objek string jika tidak maka akan dikembalikan nil.
21	arrayp Dibutuhkan satu argumen dan kembali t jika argumennya adalah objek array, jika tidak maka akan dikembalikan nil.
22	packagep Dibutuhkan satu argumen dan kembali t jika argumennya adalah sebuah paket jika tidak maka akan dikembalikan nil.

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (atom 'abcd))
(terpri)
(write (equal 'a 'b))
(terpri)
(write (evenp 10))
(terpri)
(write (evenp 7 ))
(terpri)
(write (oddp 7 ))
(terpri)
(write (zerop 0.0000000001))
(terpri)
(write (eq 3 3.0 ))
(terpri)
(write (equal 3 3.0 ))
(terpri)
(write (null nil ))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

T
NIL
T
NIL
T
NIL
NIL
NIL
T

Contoh 2

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defun factorial (num)
   (cond ((zerop num) 1)
      (t ( * num (factorial (- num 1))))
   )
)
(setq n 6)
(format t "~% Factorial ~d is: ~d" n (factorial n))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Factorial 6 is: 720

Lisp umum mendefinisikan beberapa jenis angka. Itunumber tipe data mencakup berbagai jenis angka yang didukung oleh LISP.

Jenis nomor yang didukung oleh LISP adalah -

• Integers
• Ratios
• Angka floating-point
• Bilangan kompleks

Diagram berikut menunjukkan hierarki angka dan berbagai tipe data numerik yang tersedia di LISP -

Berbagai Jenis Numerik di LISP

Tabel berikut menjelaskan berbagai jenis data nomor yang tersedia di LISP -

Sr.No.	Tipe & Deskripsi Data
1	fixnum Tipe data ini mewakili bilangan bulat yang tidak terlalu besar dan sebagian besar berkisar -215 hingga 215-1 (bergantung pada mesin)
2	bignum Ini adalah angka yang sangat besar dengan ukuran yang dibatasi oleh jumlah memori yang dialokasikan untuk LISP, ini bukan angka fixnum.
3	ratio Merupakan perbandingan dua angka dalam bentuk pembilang / penyebut. Fungsi / selalu menghasilkan hasil dalam rasio, jika argumennya adalah bilangan bulat.
4	float Ini mewakili bilangan non-integer. Ada empat tipe data float dengan presisi yang meningkat.
5	complex Ini mewakili bilangan kompleks, yang dilambangkan dengan #c. Bagian nyata dan imajiner dapat berupa bilangan rasional atau bilangan floating point.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (/ 1 2))
(terpri)
(write ( + (/ 1 2) (/ 3 4)))
(terpri)
(write ( + #c( 1 2) #c( 3 -4)))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

1/2
5/4
#C(4 -2)

Fungsi Angka

Tabel berikut menjelaskan beberapa fungsi numerik yang umum digunakan -

Sr.No.	Deskripsi fungsi
1	+, -, *, / Operasi aritmatika masing-masing
2	sin, cos, tan, acos, asin, atan Fungsi trigonometri masing-masing.
3	sinh, cosh, tanh, acosh, asinh, atanh Fungsi hiperbolik masing-masing.
4	exp Fungsi eksponen. Menghitung e x
5	expt Fungsi eksponen, mengambil basis dan kekuatan keduanya.
6	sqrt Ini menghitung akar kuadrat dari sebuah angka.
7	log Fungsi logaritmik. Jika satu parameter diberikan, kemudian dihitung logaritma aslinya, jika tidak parameter kedua digunakan sebagai basis.
8	conjugate Ini menghitung konjugasi kompleks dari sebuah bilangan. Dalam kasus bilangan real, ia mengembalikan nomor itu sendiri.
9	abs Ini mengembalikan nilai absolut (atau besarnya) sebuah angka.
10	gcd Ini menghitung pembagi persekutuan terbesar dari bilangan yang diberikan.
11	lcm Ini menghitung kelipatan persekutuan terkecil dari angka yang diberikan.
12	isqrt Ini memberikan bilangan bulat terbesar kurang dari atau sama dengan akar kuadrat tepat dari bilangan asli yang diberikan.
13	floor, ceiling, truncate, round Semua fungsi ini mengambil dua argumen sebagai angka dan mengembalikan hasil bagi; floor mengembalikan bilangan bulat terbesar yang tidak lebih besar dari rasio, ceiling memilih bilangan bulat yang lebih kecil yang lebih besar dari rasio, truncate memilih bilangan bulat dari tanda yang sama sebagai rasio dengan nilai absolut terbesar yang lebih kecil dari nilai absolut rasio, dan round memilih bilangan bulat yang paling mendekati rasio.
14	ffloor, fceiling, ftruncate, fround Melakukan hal yang sama seperti di atas, tetapi mengembalikan hasil bagi sebagai bilangan floating point.
15	mod, rem Mengembalikan sisa dalam operasi pembagian.
16	float Mengonversi bilangan real menjadi bilangan floating point.
17	rational, rationalize Mengonversi bilangan real menjadi bilangan rasional.
18	numerator, denominator Mengembalikan bagian masing-masing dari bilangan rasional.
19	realpart, imagpart Menampilkan bagian nyata dan imajiner dari bilangan kompleks.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (/ 45 78))
(terpri)
(write (floor 45 78))
(terpri)
(write (/ 3456 75))
(terpri)
(write (floor 3456 75))
(terpri)
(write (ceiling 3456 75))
(terpri)
(write (truncate 3456 75))
(terpri)
(write (round 3456 75))
(terpri)
(write (ffloor 3456 75))
(terpri)
(write (fceiling 3456 75))
(terpri)
(write (ftruncate 3456 75))
(terpri)
(write (fround 3456 75))
(terpri)
(write (mod 3456 75))
(terpri)
(setq c (complex 6 7))
(write c)
(terpri)
(write (complex 5 -9))
(terpri)
(write (realpart c))
(terpri)
(write (imagpart c))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

15/26
0
1152/25
46
47
46
46
46.0
47.0
46.0
46.0
6
#C(6 7)
#C(5 -9)
6
7

Dalam LISP, karakter direpresentasikan sebagai objek data bertipe character.

Anda dapat menunjukkan objek karakter sebelum # \ sebelum karakter itu sendiri. Misalnya, # \ a berarti karakter a.

Spasi dan karakter khusus lainnya dapat dilambangkan dengan # \ sebelum nama karakter. Misalnya, # \ SPASI mewakili karakter spasi.

Contoh berikut menunjukkan ini -

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write 'a)
(terpri)
(write #\a)
(terpri)
(write-char #\a)
(terpri)
(write-char 'a)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

A
#\a
a
*** - WRITE-CHAR: argument A is not a character

Karakter spesial

LISP umum memungkinkan penggunaan karakter khusus berikut dalam kode Anda. Mereka disebut karakter semi-standar.

• #\Backspace
• #\Tab
• #\Linefeed
• #\Page
• #\Return
• #\Rubout

Fungsi Perbandingan Karakter

Fungsi dan operator perbandingan numerik, seperti, <dan> tidak berfungsi pada karakter. LISP umum menyediakan dua set fungsi lain untuk membandingkan karakter dalam kode Anda.

Satu set peka huruf besar-kecil dan yang lainnya tidak peka huruf besar-kecil.

Tabel berikut menyediakan fungsi -

Fungsi Peka Huruf Besar-Kecil	Fungsi tidak peka huruf besar / kecil	Deskripsi
char =	char-equal	Memeriksa apakah nilai operan semua sama atau tidak, jika ya maka kondisi menjadi benar.
char / =	char-not-equal	Memeriksa apakah nilai operan semua berbeda atau tidak, jika nilai tidak sama maka kondisi menjadi benar.
char <	char-lessp	Memeriksa apakah nilai operan menurun secara monoton.
char>	char-lebih besar	Memeriksa apakah nilai operan meningkat secara monoton.
char <=	char-not-lebih besar	Memeriksa apakah nilai setiap operan kiri lebih besar dari atau sama dengan nilai operan kanan berikutnya, jika ya maka kondisi menjadi benar.
char> =	char-not-lessp	Memeriksa apakah nilai operan kiri kurang dari atau sama dengan nilai operan kanannya, jika ya maka kondisi menjadi benar.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

; case-sensitive comparison
(write (char= #\a #\b))
(terpri)
(write (char= #\a #\a))
(terpri)
(write (char= #\a #\A))
(terpri)
   
;case-insensitive comparision
(write (char-equal #\a #\A))
(terpri)
(write (char-equal #\a #\b))
(terpri)
(write (char-lessp #\a #\b #\c))
(terpri)
(write (char-greaterp #\a #\b #\c))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

NIL
T
NIL
T
NIL
T
NIL

LISP memungkinkan Anda untuk menentukan array satu atau beberapa dimensi menggunakan make-arrayfungsi. Sebuah array dapat menyimpan objek LISP apapun sebagai elemennya.

Semua array terdiri dari lokasi memori yang berdekatan. Alamat terendah sesuai dengan elemen pertama dan alamat tertinggi untuk elemen terakhir.

Jumlah dimensi dari sebuah array disebut ranknya.

Dalam LISP, elemen array ditentukan oleh urutan indeks integer non-negatif. Panjang urutan harus sama dengan pangkat array. Pengindeksan dimulai dari nol.

Misalnya, untuk membuat array dengan 10- sel, bernama my-array, kita bisa menulis -

(setf my-array (make-array '(10)))

Fungsi aref memungkinkan mengakses konten sel. Dibutuhkan dua argumen, nama array dan nilai indeks.

Misalnya, untuk mengakses konten sel kesepuluh, kami menulis -

(aref my-array 9)

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (setf my-array (make-array '(10))))
(terpri)
(setf (aref my-array 0) 25)
(setf (aref my-array 1) 23)
(setf (aref my-array 2) 45)
(setf (aref my-array 3) 10)
(setf (aref my-array 4) 20)
(setf (aref my-array 5) 17)
(setf (aref my-array 6) 25)
(setf (aref my-array 7) 19)
(setf (aref my-array 8) 67)
(setf (aref my-array 9) 30)
(write my-array)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
#(25 23 45 10 20 17 25 19 67 30)

Contoh 2

Mari kita buat array 3-kali-3.

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setf x (make-array '(3 3) 
   :initial-contents '((0 1 2 ) (3 4 5) (6 7 8)))
)
(write x)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#2A((0 1 2) (3 4 5) (6 7 8))

Contoh 3

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq a (make-array '(4 3)))
(dotimes (i 4)
   (dotimes (j 3)
      (setf (aref a i j) (list i 'x j '= (* i j)))
   )
)
(dotimes (i 4)
   (dotimes (j 3)
      (print (aref a i j))
   )
)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(0 X 0 = 0) 
(0 X 1 = 0) 
(0 X 2 = 0) 
(1 X 0 = 0) 
(1 X 1 = 1) 
(1 X 2 = 2) 
(2 X 0 = 0) 
(2 X 1 = 2) 
(2 X 2 = 4) 
(3 X 0 = 0) 
(3 X 1 = 3) 
(3 X 2 = 6)

Sintaks Lengkap untuk Fungsi make-array

Fungsi make-array mengambil banyak argumen lain. Mari kita lihat sintaks lengkap dari fungsi ini -

make-array dimensions :element-type :initial-element :initial-contents :adjustable :fill-pointer  :displaced-to :displaced-index-offset

Terlepas dari argumen dimensi , semua argumen lainnya adalah kata kunci. Tabel berikut memberikan penjelasan singkat tentang argumen.

Sr.No.	Argumen & Deskripsi
1	dimensions Ini memberikan dimensi array. Ini adalah angka untuk larik satu dimensi, dan daftar untuk larik multidimensi.
2	:element-type Ini adalah penentu tipe, nilai defaultnya adalah T, yaitu tipe apa saja
3	:initial-element Nilai elemen awal. Ini akan membuat array dengan semua elemen yang diinisialisasi ke nilai tertentu.
4	:initial-content Konten awal sebagai objek.
5	:adjustable Ini membantu dalam membuat vektor yang dapat diubah ukurannya (atau dapat disesuaikan) yang memori dasarnya dapat diubah ukurannya. Argumennya adalah nilai Boolean yang menunjukkan apakah array dapat disesuaikan atau tidak, nilai defaultnya adalah NIL.
6	:fill-pointer Ini melacak jumlah elemen yang sebenarnya disimpan dalam vektor yang dapat diubah ukurannya.
7	:displaced-to Ini membantu dalam membuat larik yang dipindahkan atau larik bersama yang membagikan isinya dengan larik yang ditentukan. Kedua array harus memiliki tipe elemen yang sama. Opsi: displaced-to tidak boleh digunakan dengan opsi: initial-element atau: opsi-isi awal. Argumen ini defaultnya nol.
8	:displaced-index-offset Ini memberikan indeks-offset dari array bersama yang dibuat.

Contoh 4

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq myarray (make-array '(3 2 3) 
   :initial-contents 
   '(((a b c) (1 2 3)) 
      ((d e f) (4 5 6)) 
      ((g h i) (7 8 9)) 
   ))
) 
(setq array2 (make-array 4 :displaced-to myarray :displaced-index-offset 2)) 
(write myarray)
(terpri)
(write array2)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#3A(((A B C) (1 2 3)) ((D E F) (4 5 6)) ((G H I) (7 8 9)))
#(C 1 2 3)

Jika array yang dipindahkan adalah dua dimensi -

(setq myarray (make-array '(3 2 3) 
   :initial-contents 
   '(((a b c) (1 2 3)) 
      ((d e f) (4 5 6)) 
      ((g h i) (7 8 9)) 
   ))
) 
(setq array2 (make-array '(3 2) :displaced-to myarray :displaced-index-offset 2)) 
(write myarray)
(terpri)
(write array2)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#3A(((A B C) (1 2 3)) ((D E F) (4 5 6)) ((G H I) (7 8 9)))
#2A((C 1) (2 3) (D E))

Mari kita ubah offset indeks yang dipindahkan menjadi 5 -

(setq myarray (make-array '(3 2 3) 
   :initial-contents 
   '(((a b c) (1 2 3)) 
      ((d e f) (4 5 6)) 
      ((g h i) (7 8 9)) 
   ))
) 
(setq array2 (make-array '(3 2) :displaced-to myarray :displaced-index-offset 5)) 
(write myarray)
(terpri)
(write array2)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#3A(((A B C) (1 2 3)) ((D E F) (4 5 6)) ((G H I) (7 8 9)))
#2A((3 D) (E F) (4 5))

Contoh 5

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

;a one dimensional array with 5 elements, 
;initail value 5
(write (make-array 5 :initial-element 5))
(terpri)

;two dimensional array, with initial element a
(write (make-array '(2 3) :initial-element 'a))
(terpri)

;an array of capacity 14, but fill pointer 5, is 5
(write(length (make-array 14 :fill-pointer 5)))
(terpri)

;however its length is 14
(write (array-dimensions (make-array 14 :fill-pointer 5)))
(terpri)

; a bit array with all initial elements set to 1
(write(make-array 10 :element-type 'bit :initial-element 1))
(terpri)

; a character array with all initial elements set to a
; is a string actually
(write(make-array 10 :element-type 'character :initial-element #\a)) 
(terpri)

; a two dimensional array with initial values a
(setq myarray (make-array '(2 2) :initial-element 'a :adjustable t))
(write myarray)
(terpri)

;readjusting the array
(adjust-array myarray '(1 3) :initial-element 'b) 
(write myarray)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#(5 5 5 5 5)
#2A((A A A) (A A A))
5
(14)
#*1111111111
"aaaaaaaaaa"
#2A((A A) (A A))
#2A((A A B))

String dalam Common Lisp adalah vektor, yaitu larik karakter satu dimensi.

Literal string diapit tanda kutip ganda. Setiap karakter yang didukung oleh himpunan karakter dapat diapit dalam tanda kutip ganda untuk membuat string, kecuali karakter tanda kutip ganda (") dan karakter escape (\). Namun, Anda dapat menyertakannya dengan meng-escape dengan garis miring terbalik (\).

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write-line "Hello World")
(write-line "Welcome to Tutorials Point")

;escaping the double quote character
(write-line "Welcome to \"Tutorials Point\"")

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Hello World
Welcome to Tutorials Point
Welcome to "Tutorials Point"

Fungsi Perbandingan String

Fungsi dan operator perbandingan numerik, seperti, <dan> tidak berfungsi pada string. LISP umum menyediakan dua set fungsi lain untuk membandingkan string dalam kode Anda. Satu set peka huruf besar-kecil dan yang lainnya tidak peka huruf besar-kecil.

Tabel berikut menyediakan fungsi -

Fungsi Peka Huruf Besar-Kecil	Fungsi tidak peka huruf besar / kecil	Deskripsi
string =	string-sama	Memeriksa apakah nilai operan semua sama atau tidak, jika ya maka kondisi menjadi benar.
string / =	string-tidak-sama	Memeriksa apakah nilai operan semua berbeda atau tidak, jika nilai tidak sama maka kondisi menjadi benar.
string <	string-lessp	Memeriksa apakah nilai operan menurun secara monoton.
string>	string-lebih besar	Memeriksa apakah nilai operan meningkat secara monoton.
string <=	string-tidak-lebih besar	Memeriksa apakah nilai setiap operan kiri lebih besar dari atau sama dengan nilai operan kanan berikutnya, jika ya maka kondisi menjadi benar.
string> =	string-not-lessp	Memeriksa apakah nilai operan kiri kurang dari atau sama dengan nilai operan kanannya, jika ya maka kondisi menjadi benar.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

; case-sensitive comparison
(write (string= "this is test" "This is test"))
(terpri)
(write (string> "this is test" "This is test"))
(terpri)
(write (string< "this is test" "This is test"))
(terpri)

;case-insensitive comparision
(write (string-equal "this is test" "This is test"))
(terpri)
(write (string-greaterp "this is test" "This is test"))
(terpri)
(write (string-lessp "this is test" "This is test"))
(terpri)

;checking non-equal
(write (string/= "this is test" "this is Test"))
(terpri)
(write (string-not-equal "this is test" "This is test"))
(terpri)
(write (string/= "lisp" "lisping"))
(terpri)
(write (string/= "decent" "decency"))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

NIL
0
NIL
T
NIL
NIL
8
NIL
4
5

Fungsi Pengendalian Kasus

Tabel berikut menjelaskan fungsi pengendalian kasus -

Sr.No.	Deskripsi fungsi
1	string-upcase Mengonversi string menjadi huruf besar
2	string-downcase Mengonversi string menjadi huruf kecil
3	string-capitalize Kapitalisasi setiap kata dalam string

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write-line (string-upcase "a big hello from tutorials point"))
(write-line (string-capitalize "a big hello from tutorials point"))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

A BIG HELLO FROM TUTORIALS POINT
A Big Hello From Tutorials Point

Memangkas String

Tabel berikut menjelaskan fungsi pemangkasan string -

Sr.No.	Deskripsi fungsi
1	string-trim Ini mengambil string karakter sebagai argumen pertama dan string sebagai argumen kedua dan mengembalikan substring di mana semua karakter yang ada di argumen pertama dihapus dari string argumen.
2	String-left-trim Ini mengambil string karakter sebagai argumen pertama dan string sebagai argumen kedua dan mengembalikan substring di mana semua karakter yang ada di argumen pertama dihapus dari awal string argumen.
3	String-right-trim Ini mengambil karakter string sebagai argumen pertama dan string sebagai argumen kedua dan mengembalikan substring di mana semua karakter yang ada di argumen pertama dihapus dari akhir string argumen.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write-line (string-trim " " "   a big hello from tutorials point   "))
(write-line (string-left-trim " " "   a big hello from tutorials point   "))
(write-line (string-right-trim " " "   a big hello from tutorials point   "))
(write-line (string-trim " a" "   a big hello from tutorials point   "))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

a big hello from tutorials point
a big hello from tutorials point   
   a big hello from tutorials point
big hello from tutorials point

Fungsi String Lainnya

String dalam LISP adalah array dan juga urutan. Kami akan membahas tipe data ini dalam tutorial mendatang. Semua fungsi yang berlaku untuk array dan urutan juga berlaku untuk string. Namun, kami akan mendemonstrasikan beberapa fungsi yang umum digunakan menggunakan berbagai contoh.

Menghitung Panjang

Itu length fungsi menghitung panjang string.

Mengekstrak Sub-string

Itu subseq fungsi mengembalikan sub-string (sebagai string juga merupakan urutan) mulai dari indeks tertentu dan melanjutkan ke indeks akhir atau akhir string tertentu.

Mengakses Karakter dalam String

Itu char fungsi memungkinkan mengakses karakter individu dari sebuah string.

Example

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (length "Hello World"))
(terpri)
(write-line (subseq "Hello World" 6))
(write (char "Hello World" 6))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

11
World
#\W

Menyortir dan Menggabungkan String

Itu sortfungsi memungkinkan pengurutan string. Dibutuhkan urutan (vektor atau string) dan predikat dua argumen dan mengembalikan versi urutan yang diurutkan.

Itu merge Fungsi mengambil dua urutan dan predikat dan mengembalikan urutan yang dihasilkan dengan menggabungkan dua urutan, sesuai dengan predikatnya.

Example

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

;sorting the strings
(write (sort (vector "Amal" "Akbar" "Anthony") #'string<))
(terpri)

;merging the strings
(write (merge 'vector (vector "Rishi" "Zara" "Priyanka") 
   (vector "Anju" "Anuj" "Avni") #'string<))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#("Akbar" "Amal" "Anthony")
#("Anju" "Anuj" "Avni" "Rishi" "Zara" "Priyanka")

Membalikkan String

Itu reverse fungsi membalikkan string.

Misalnya, Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write-line (reverse "Are we not drawn onward, we few, drawn onward to new era"))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

are wen ot drawno nward ,wef ew ,drawno nward ton ew erA

String Penggabungan

Fungsi penggabungan menggabungkan dua string. Ini adalah fungsi urutan umum dan Anda harus memberikan tipe hasil sebagai argumen pertama.

Misalnya, Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write-line (concatenate 'string "Are we not drawn onward, " "we few, drawn onward to new era"))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Are we not drawn onward, we few, drawn onward to new era

Urutan adalah tipe data abstrak di LISP. Vektor dan daftar adalah dua subtipe konkret dari tipe data ini. Semua fungsi yang didefinisikan pada tipe data urutan sebenarnya diterapkan pada semua vektor dan tipe daftar.

Pada bagian ini, kita akan membahas fungsi yang paling umum digunakan pada urutan.

Sebelum memulai berbagai cara memanipulasi urutan (mis., Vektor dan daftar), mari kita lihat daftar semua fungsi yang tersedia.

Membuat Urutan

Fungsi make-sequence memungkinkan Anda membuat urutan jenis apa pun. Sintaks untuk fungsi ini adalah -

make-sequence sqtype sqsize &key :initial-element

Ini menciptakan urutan tipe sqtype dan panjang sqsize.

Secara opsional, Anda dapat menentukan beberapa nilai menggunakan argumen: elemen awal , lalu setiap elemen akan diinisialisasi ke nilai ini.

Misalnya, Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (make-sequence '(vector float) 
   10 
   :initial-element 1.0))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#(1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0)

Fungsi Generik pada Urutan

Sr.No.	Deskripsi fungsi
1	elt Ini memungkinkan akses ke elemen individu melalui indeks integer.
2	length Ini mengembalikan panjang urutan.
3	subseq Ini mengembalikan sub-urutan dengan mengekstraksi urutan yang dimulai dari indeks tertentu dan melanjutkan ke indeks akhir tertentu atau akhir urutan.
4	copy-seq Ini mengembalikan urutan yang berisi elemen yang sama dengan argumennya.
5	fill Ini digunakan untuk mengatur beberapa elemen urutan ke satu nilai.
6	replace Dibutuhkan dua urutan dan urutan argumen pertama dimodifikasi secara destruktif dengan menyalin elemen berurutan ke dalamnya dari urutan argumen kedua.
7	count Ini mengambil item dan urutan dan mengembalikan berapa kali item tersebut muncul dalam urutan.
8	reverse Ini mengembalikan urutan berisi elemen yang sama dari argumen tetapi dalam urutan terbalik.
9	nreverse Ini mengembalikan urutan yang sama yang mengandung elemen yang sama sebagai urutan tetapi dalam urutan terbalik.
10	concatenate Ini menciptakan urutan baru yang berisi penggabungan sejumlah urutan.
11	position Dibutuhkan item dan urutan dan mengembalikan indeks item dalam urutan atau nihil.
12	find Dibutuhkan item dan urutan. Ia menemukan item dalam urutan dan mengembalikannya, jika tidak ditemukan maka ia mengembalikan nihil.
13	sort Ini mengambil urutan dan predikat dua argumen dan mengembalikan versi urutan yang diurutkan.
14	merge Dibutuhkan dua urutan dan satu predikat dan mengembalikan urutan yang dihasilkan dengan menggabungkan dua urutan tersebut, sesuai dengan predikatnya.
15	map Dibutuhkan fungsi n-argumen dan n urutan dan mengembalikan urutan baru yang berisi hasil penerapan fungsi ke elemen urutan berikutnya.
16	some Ini mengambil predikat sebagai argumen dan mengulangi urutan argumen, dan mengembalikan nilai non-NIL pertama yang dikembalikan oleh predikat atau mengembalikan salah jika predikat tidak pernah terpenuhi.
17	every Dibutuhkan predikat sebagai argumen dan mengulangi urutan argumen, itu berakhir, mengembalikan salah, segera setelah predikat gagal. Jika predikat selalu terpenuhi, ia mengembalikan nilai true.
18	notany Ini mengambil predikat sebagai argumen dan mengulangi urutan argumen, dan mengembalikan false segera setelah predikat terpenuhi atau benar jika tidak pernah.
19	notevery Ini mengambil predikat sebagai argumen dan mengulangi urutan argumen, dan mengembalikan nilai benar segera setelah predikat gagal atau salah jika predikat selalu terpenuhi.
20	reduce Ini memetakan satu urutan, menerapkan fungsi dua argumen pertama ke dua elemen pertama dari urutan dan kemudian ke nilai yang dikembalikan oleh fungsi dan elemen berikutnya dari urutan tersebut.
21	search Ini mencari urutan untuk menemukan satu atau lebih elemen yang memenuhi beberapa tes.
22	remove Dibutuhkan item dan urutan dan mengembalikan urutan dengan contoh item dihapus.
23	delete Ini juga mengambil item dan urutan dan mengembalikan urutan yang sama seperti urutan argumen yang memiliki elemen yang sama kecuali item tersebut.
24	substitute Dibutuhkan item baru, item yang sudah ada, dan urutan dan mengembalikan urutan dengan contoh item yang ada diganti dengan item baru.
25	nsubstitute Dibutuhkan item baru, item yang sudah ada, dan urutan dan mengembalikan urutan yang sama dengan contoh item yang ada diganti dengan item baru.
26	mismatch Ini mengambil dua urutan dan mengembalikan indeks dari pasangan pertama elemen yang tidak cocok.

Argumen Kata Kunci Fungsi Urutan Standar

Argumen	Berarti	Nilai Default
:uji	Ini adalah fungsi dua argumen yang digunakan untuk membandingkan item (atau nilai yang diekstrak oleh: fungsi kunci) dengan elemen.	EQL
:kunci	Fungsi satu argumen untuk mengekstrak nilai kunci dari elemen urutan sebenarnya. NIL berarti menggunakan elemen apa adanya.	NOL
:Mulailah	Indeks awal (termasuk) selanjutnya.	0
:akhir	Indeks akhir (eksklusif) dari urutan. NIL menunjukkan akhir urutan.	NOL
: dari akhir	Jika benar, urutan akan dilintasi dalam urutan terbalik, dari akhir ke awal.	NOL
:menghitung	Nomor yang menunjukkan jumlah elemen yang akan dihapus atau diganti atau NIL untuk menunjukkan semua (HAPUS dan PENGGANTI saja).	NOL

Kami baru saja membahas berbagai fungsi dan kata kunci yang digunakan sebagai argumen dalam fungsi yang mengerjakan urutan ini. Di bagian selanjutnya, kita akan melihat bagaimana menggunakan fungsi ini menggunakan contoh.

Menemukan Panjang dan Elemen

Itu length fungsi mengembalikan panjang urutan, dan elt fungsi memungkinkan Anda untuk mengakses elemen individu menggunakan indeks integer.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq x (vector 'a 'b 'c 'd 'e))
(write (length x))
(terpri)
(write (elt x 3))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

5
D

Mengubah Urutan

Beberapa fungsi urutan memungkinkan iterasi melalui urutan dan melakukan beberapa operasi seperti, mencari, menghapus, menghitung, atau memfilter elemen tertentu tanpa menulis loop eksplisit.

Contoh berikut menunjukkan ini -

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (count 7 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (remove 5 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (delete 5 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (substitute 10 7 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (find 7 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (position 5 '(1 5 6 7 8 9 2 7 3 4 5)))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

2
(1 6 7 8 9 2 7 3 4)
(1 6 7 8 9 2 7 3 4)
(1 5 6 10 8 9 2 10 3 4 5)
7
1

Contoh 2

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (delete-if #'oddp '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (delete-if #'evenp '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (remove-if #'evenp '(1 5 6 7 8 9 2 7 3 4 5) :count 1 :from-end t))
(terpri)
(setq x (vector 'a 'b 'c 'd 'e 'f 'g))
(fill x 'p :start 1 :end 4)
(write x)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(6 8 2 4)
(1 5 7 9 7 3 5)
(1 5 6 7 8 9 2 7 3 5)
#(A P P P E F G)

Urutan Sorting dan Penggabungan

Fungsi pengurutan mengambil urutan dan predikat dua argumen dan mengembalikan versi urutan yang diurutkan.

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (sort '(2 4 7 3 9 1 5 4 6 3 8) #'<))
(terpri)
(write (sort '(2 4 7 3 9 1 5 4 6 3 8) #'>))
(terpri)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(1 2 3 3 4 4 5 6 7 8 9)
(9 8 7 6 5 4 4 3 3 2 1)

Contoh 2

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (merge 'vector #(1 3 5) #(2 4 6) #'<))
(terpri)
(write (merge 'list #(1 3 5) #(2 4 6) #'<))
(terpri)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#(1 2 3 4 5 6)
(1 2 3 4 5 6)

Predikat Urutan

Fungsi setiap, beberapa, notany, dan notevery disebut predikat urutan.

Fungsi-fungsi ini melakukan iterasi atas urutan dan menguji predikat Boolean.

Semua fungsi ini mengambil predikat sebagai argumen pertama dan argumen yang tersisa adalah urutan.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (every #'evenp #(2 4 6 8 10)))
(terpri)
(write (some #'evenp #(2 4 6 8 10 13 14)))
(terpri)
(write (every #'evenp #(2 4 6 8 10 13 14)))
(terpri)
(write (notany #'evenp #(2 4 6 8 10)))
(terpri)
(write (notevery #'evenp #(2 4 6 8 10 13 14)))
(terpri)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

T
T
NIL
NIL
T

Urutan Pemetaan

Kami telah membahas fungsi pemetaan. Demikian pulamap function memungkinkan Anda untuk menerapkan fungsi ke elemen berikutnya dari satu atau lebih urutan.

Itu map Fungsi mengambil fungsi n-argumen dan n urutan dan mengembalikan urutan baru setelah menerapkan fungsi ke elemen berikutnya dari urutan.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (map 'vector #'* #(2 3 4 5) #(3 5 4 8)))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#(6 15 16 40)

Daftar merupakan struktur data komposit yang paling penting dan utama dalam LISP tradisional. LISP Umum saat ini menyediakan struktur data lain seperti, vektor, tabel hash, kelas atau struktur.

Daftar adalah daftar tertaut tunggal. Di LISP, daftar dibuat sebagai rangkaian struktur rekaman sederhana bernamacons dihubungkan bersama.

Kontra Struktur Rekaman

SEBUAH cons adalah struktur record yang berisi dua komponen yang disebut car dan cdr.

Kontra sel atau kontra adalah objek pasangan nilai yang dibuat menggunakan fungsi cons.

Itu consfunction mengambil dua argumen dan mengembalikan sel kontra baru yang berisi dua nilai. Nilai-nilai ini dapat menjadi referensi untuk segala jenis objek.

Jika nilai kedua bukan nol, atau sel kontra lainnya, maka nilai akan dicetak sebagai pasangan titik-titik yang diapit oleh tanda kurung.

Dua nilai dalam sel kontra disebut car dan cdr. Itu car fungsi digunakan untuk mengakses nilai pertama dan cdr fungsi digunakan untuk mengakses nilai kedua.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (cons 1 2))
(terpri)
(write (cons 'a 'b))
(terpri)
(write (cons 1 nil))
(terpri)
(write (cons 1 (cons 2 nil)))
(terpri)
(write (cons 1 (cons 2 (cons 3 nil))))
(terpri)
(write (cons 'a (cons 'b (cons 'c nil))))
(terpri)
(write ( car (cons 'a (cons 'b (cons 'c nil)))))
(terpri)
(write ( cdr (cons 'a (cons 'b (cons 'c nil)))))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(1 . 2)
(A . B)
(1)
(1 2)
(1 2 3)
(A B C)
A
(B C)

Contoh di atas menunjukkan bagaimana struktur kontra dapat digunakan untuk membuat daftar tertaut tunggal, misalnya, daftar (ABC) terdiri dari tiga sel kontra yang dihubungkan bersama oleh cdr mereka .

Secara diagram, ini dapat dinyatakan sebagai -

Daftar di LISP

Meskipun sel kontra dapat digunakan untuk membuat daftar, namun, membuat daftar dari bersarang conspanggilan fungsi tidak bisa menjadi solusi terbaik. Itulist fungsi lebih digunakan untuk membuat daftar di LISP.

Fungsi list dapat mengambil sejumlah argumen dan karena ini adalah fungsi, ia mengevaluasi argumennya.

Itu first dan restfungsi memberikan elemen pertama dan bagian lainnya dari daftar. Contoh berikut menunjukkan konsepnya.

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (list 1 2))
(terpri)
(write (list 'a 'b))
(terpri)
(write (list 1 nil))
(terpri)
(write (list 1 2 3))
(terpri)
(write (list 'a 'b 'c))
(terpri)
(write (list 3 4 'a (car '(b . c)) (* 4 -2)))
(terpri)
(write (list (list 'a 'b) (list 'c 'd 'e)))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(1 2)
(A B)
(1 NIL)
(1 2 3)
(A B C)
(3 4 A B -8)
((A B) (C D E))

Contoh 2

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defun my-library (title author rating availability)
   (list :title title :author author :rating rating :availabilty availability)
)

(write (getf (my-library "Hunger Game" "Collins" 9 t) :title))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

"Hunger Game"

Buat Daftar Fungsi Memanipulasi

Tabel berikut menyediakan beberapa fungsi manipulasi daftar yang umum digunakan.

Sr.No.	Deskripsi fungsi
1	car Ini mengambil list sebagai argumen, dan mengembalikan elemen pertamanya.
2	cdr Dibutuhkan daftar sebagai argumen, dan mengembalikan daftar tanpa elemen pertama
3	cons Dibutuhkan dua argumen, elemen dan daftar dan mengembalikan daftar dengan elemen yang disisipkan di tempat pertama.
4	list Dibutuhkan sejumlah argumen dan mengembalikan daftar dengan argumen sebagai elemen anggota daftar.
5	append Ini menggabungkan dua atau lebih daftar menjadi satu.
6	last Ini mengambil daftar dan mengembalikan daftar yang berisi elemen terakhir.
7	member Dibutuhkan dua argumen yang yang kedua harus berupa daftar, jika argumen pertama adalah anggota dari argumen kedua, dan kemudian mengembalikan sisa daftar yang dimulai dengan argumen pertama.
8	reverse Dibutuhkan daftar dan mengembalikan daftar dengan elemen teratas dalam urutan terbalik.

Harap dicatat bahwa semua fungsi urutan berlaku untuk daftar.

Contoh 3

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (car '(a b c d e f)))
(terpri)
(write (cdr '(a b c d e f)))
(terpri)
(write (cons 'a '(b c)))
(terpri)
(write (list 'a '(b c) '(e f)))
(terpri)
(write (append '(b c) '(e f) '(p q) '() '(g)))
(terpri)
(write (last '(a b c d (e f))))
(terpri)
(write (reverse '(a b c d (e f))))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

A
(B C D E F)
(A B C)
(A (B C) (E F))
(B C E F P Q G)
((E F))
((E F) D C B A)

Penggabungan Fungsi mobil dan cdr

Itu car dan cdr fungsi dan kombinasinya memungkinkan ekstraksi elemen / anggota tertentu dari daftar.

Namun urutan fungsi car dan cdr dapat disingkat dengan menggabungkan huruf a untuk car dan d untuk cdr di dalam huruf c dan r.

Misalnya kita dapat menulis cadadr untuk menyingkat urutan panggilan fungsi - car cdr car cdr.

Jadi, (cadadr '(a (cd) (efg))) akan mengembalikan d

Contoh 4

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (cadadr '(a (c d) (e f g))))
(terpri)
(write (caar (list (list 'a 'b) 'c)))   
(terpri)
(write (cadr (list (list 1 2) (list 3 4))))
(terpri)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

D
A
(3 4)

Dalam LISP simbol adalah nama yang merepresentasikan objek data dan yang menarik juga merupakan objek data.

Apa yang membuat simbol spesial adalah mereka memiliki komponen yang disebut property list, atau plist.

Daftar Properti

LISP memungkinkan Anda untuk menetapkan properti ke simbol. Misalnya, mari kita memiliki objek 'orang'. Kami ingin objek 'orang' ini memiliki properti seperti nama, jenis kelamin, tinggi badan, berat badan, alamat, profesi, dll. Properti itu seperti nama atribut.

Daftar properti diimplementasikan sebagai daftar dengan elemen bilangan genap (kemungkinan nol). Setiap pasangan elemen dalam daftar merupakan entri; item pertama adalahindicator, dan yang kedua adalah value.

Ketika sebuah simbol dibuat, daftar propertinya pada awalnya kosong. Properti dibuat dengan menggunakanget dalam a setf bentuk.

Misalnya, pernyataan berikut memungkinkan kita untuk menetapkan judul properti, penulis dan penerbit, dan nilai masing-masing, ke objek bernama (simbol) 'buku'.

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (setf (get 'books'title) '(Gone with the Wind)))
(terpri)
(write (setf (get 'books 'author) '(Margaret Michel)))
(terpri)
(write (setf (get 'books 'publisher) '(Warner Books)))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(GONE WITH THE WIND)
(MARGARET MICHEL)
(WARNER BOOKS)

Berbagai fungsi daftar properti memungkinkan Anda menetapkan properti serta mengambil, mengganti, atau menghapus properti simbol.

Itu getfungsi mengembalikan daftar properti simbol untuk indikator tertentu. Ini memiliki sintaks berikut -

get symbol indicator &optional default

Itu getfungsi mencari daftar properti dari simbol yang diberikan untuk indikator yang ditentukan, jika ditemukan maka ia mengembalikan nilai yang sesuai; jika tidak default dikembalikan (atau nihil, jika nilai default tidak ditentukan).

Contoh 2

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setf (get 'books 'title) '(Gone with the Wind))
(setf (get 'books 'author) '(Margaret Micheal))
(setf (get 'books 'publisher) '(Warner Books))

(write (get 'books 'title))
(terpri)
(write (get 'books 'author))
(terpri)
(write (get 'books 'publisher))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(GONE WITH THE WIND)
(MARGARET MICHEAL)
(WARNER BOOKS)

Itu symbol-plist fungsi memungkinkan Anda untuk melihat semua properti simbol.

Contoh 3

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setf (get 'annie 'age) 43)
(setf (get 'annie 'job) 'accountant)
(setf (get 'annie 'sex) 'female)
(setf (get 'annie 'children) 3)

(terpri)
(write (symbol-plist 'annie))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(CHILDREN 3 SEX FEMALE JOB ACCOUNTANT AGE 43)

Itu remprop fungsi menghapus properti tertentu dari simbol.

Contoh 4

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setf (get 'annie 'age) 43)
(setf (get 'annie 'job) 'accountant)
(setf (get 'annie 'sex) 'female)
(setf (get 'annie 'children) 3)

(terpri)
(write (symbol-plist 'annie))
(remprop 'annie 'age)
(terpri)
(write (symbol-plist 'annie))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(CHILDREN 3 SEX FEMALE JOB ACCOUNTANT AGE 43)
(CHILDREN 3 SEX FEMALE JOB ACCOUNTANT)

Vektor adalah larik satu dimensi, oleh karena itu merupakan subtipe larik. Vektor dan daftar secara kolektif disebut urutan. Oleh karena itu semua fungsi generik urutan dan fungsi array yang telah kita bahas sejauh ini, bekerja pada vektor.

Membuat Vektor

Fungsi vektor memungkinkan Anda membuat vektor berukuran tetap dengan nilai tertentu. Dibutuhkan sejumlah argumen dan mengembalikan vektor yang berisi argumen tersebut.

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setf v1 (vector 1 2 3 4 5))
(setf v2 #(a b c d e))
(setf v3 (vector 'p 'q 'r 's 't))

(write v1)
(terpri)
(write v2)
(terpri)
(write v3)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#(1 2 3 4 5)
#(A B C D E)
#(P Q R S T)

Harap dicatat bahwa LISP menggunakan sintaks # (...) sebagai notasi literal untuk vektor. Anda dapat menggunakan sintaks # (...) ini untuk membuat dan menyertakan vektor literal dalam kode Anda.

Namun, ini adalah vektor literal, jadi mengubahnya tidak ditentukan dalam LISP. Oleh karena itu, untuk pemrograman, Anda harus selalu menggunakanvector fungsi, atau fungsi yang lebih umum make-array untuk membuat vektor yang ingin Anda modifikasi.

Itu make-arrayfungsi adalah cara yang lebih umum untuk membuat vektor. Anda dapat mengakses elemen vektor menggunakanaref fungsi.

Contoh 2

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq a (make-array 5 :initial-element 0))
(setq b (make-array 5 :initial-element 2))

(dotimes (i 5)
   (setf (aref a i) i))
   
(write a)
(terpri)
(write b)
(terpri)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#(0 1 2 3 4)
#(2 2 2 2 2)

Isi Pointer

Itu make-array fungsi memungkinkan Anda membuat vektor yang dapat diubah ukurannya.

Itu fill-pointerargumen fungsi melacak jumlah elemen yang sebenarnya disimpan dalam vektor. Ini adalah indeks dari posisi berikutnya yang harus diisi saat Anda menambahkan elemen ke vektor.

Itu vector-pushfungsi memungkinkan Anda untuk menambahkan elemen ke akhir vektor yang dapat diubah ukurannya. Ini meningkatkan penunjuk pengisian sebesar 1.

Itu vector-pop fungsi mengembalikan item yang paling baru didorong dan mengurangi penunjuk isian sebesar 1.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq a (make-array 5 :fill-pointer 0))
(write a)

(vector-push 'a a)
(vector-push 'b a)
(vector-push 'c a)

(terpri)
(write a)
(terpri)

(vector-push 'd a)
(vector-push 'e a)

;this will not be entered as the vector limit is 5
(vector-push 'f a)

(write a)
(terpri)

(vector-pop a)
(vector-pop a)
(vector-pop a)

(write a)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#()
#(A B C)
#(A B C D E)
#(A B)

Vektor adalah urutan, semua fungsi urutan dapat diterapkan untuk vektor. Silakan baca bab urutan, untuk fungsi vektor.

Lisp umum tidak menyediakan tipe data set. Namun, ini menyediakan sejumlah fungsi yang memungkinkan operasi set dilakukan pada daftar.

Anda dapat menambah, menghapus, dan mencari item dalam daftar, berdasarkan berbagai kriteria. Anda juga dapat melakukan berbagai operasi himpunan seperti: union, intersection, dan set difference.

Menerapkan Set di LISP

Set, seperti daftar biasanya diimplementasikan dalam bentuk sel kontra. Namun, untuk alasan ini, operasi set menjadi semakin tidak efisien semakin besar set yang didapat.

Itu adjoinfungsi memungkinkan Anda untuk membangun satu set. Dibutuhkan item dan daftar yang mewakili satu set dan mengembalikan daftar yang mewakili set yang berisi item dan semua item dalam set asli.

Itu adjoinfungsi pertama mencari item dalam daftar yang diberikan, jika ditemukan, kemudian mengembalikan daftar asli; jika tidak, itu membuat sel kontra baru dengan nyacar sebagai item dan cdr menunjuk ke daftar asli dan mengembalikan daftar baru ini.

Itu adjoin fungsi juga membutuhkan :key dan :testargumen kata kunci. Argumen ini digunakan untuk memeriksa apakah item tersebut ada dalam daftar asli.

Karena, fungsi adjoin tidak mengubah daftar asli, untuk membuat perubahan dalam daftar itu sendiri, Anda harus menetapkan nilai yang dikembalikan oleh adjoin ke daftar asli atau, Anda dapat menggunakan makro pushnew untuk menambahkan item ke set.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

; creating myset as an empty list
(defparameter *myset* ())
(adjoin 1 *myset*)
(adjoin 2 *myset*)

; adjoin did not change the original set
;so it remains same
(write *myset*)
(terpri)
(setf *myset* (adjoin 1 *myset*))
(setf *myset* (adjoin 2 *myset*))

;now the original set is changed
(write *myset*)
(terpri)

;adding an existing value
(pushnew 2 *myset*)

;no duplicate allowed
(write *myset*)
(terpri)

;pushing a new value
(pushnew 3 *myset*)
(write *myset*)
(terpri)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

NIL
(2 1)
(2 1)
(3 2 1)

Memeriksa Keanggotaan

Fungsi grup anggota memungkinkan Anda untuk memeriksa apakah suatu elemen adalah anggota dari suatu himpunan atau bukan.

Berikut ini adalah sintaks dari fungsi-fungsi ini -

member item list &key :test :test-not :key 
member-if predicate list &key :key 
member-if-not predicate list &key :key

Fungsi-fungsi ini mencari daftar yang diberikan untuk item tertentu yang memenuhi tes. Jika tidak ada item yang ditemukan, maka fungsinya akan kembalinil. Jika tidak, ekor daftar dengan elemen sebagai elemen pertama akan dikembalikan.

Pencarian dilakukan hanya di tingkat atas.

Fungsi-fungsi ini bisa digunakan sebagai predikat.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(write (member 'zara '(ayan abdul zara riyan nuha)))
(terpri)
(write (member-if #'evenp '(3 7 2 5/3 'a)))
(terpri)
(write (member-if-not #'numberp '(3 7 2 5/3 'a 'b 'c)))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(ZARA RIYAN NUHA)
(2 5/3 'A)
('A 'B 'C)

Atur Serikat

Grup fungsi gabungan memungkinkan Anda melakukan kumpulan kumpulan pada dua daftar yang disediakan sebagai argumen untuk fungsi ini berdasarkan pengujian.

Berikut ini adalah sintaks dari fungsi-fungsi ini -

union list1 list2 &key :test :test-not :key 
nunion list1 list2 &key :test :test-not :key

Itu unionfunction mengambil dua daftar dan mengembalikan daftar baru yang berisi semua elemen yang ada di salah satu daftar. Jika ada duplikasi, maka hanya satu salinan anggota yang disimpan dalam daftar yang dikembalikan.

Itu nunion fungsi melakukan operasi yang sama tetapi dapat menghancurkan daftar argumen.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq set1 (union '(a b c) '(c d e)))
(setq set2 (union '(#(a b) #(5 6 7) #(f h)) 
   '(#(5 6 7) #(a b) #(g h)) :test-not #'mismatch)
)
       
(setq set3 (union '(#(a b) #(5 6 7) #(f h)) 
   '(#(5 6 7) #(a b) #(g h)))
)
(write set1)
(terpri)
(write set2)
(terpri)
(write set3)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(A B C D E)
(#(F H) #(5 6 7) #(A B) #(G H))
(#(A B) #(5 6 7) #(F H) #(5 6 7) #(A B) #(G H))

Tolong dicatat

Fungsi serikat tidak berfungsi seperti yang diharapkan tanpa :test-not #'mismatchargumen untuk daftar tiga vektor. Ini karena, daftar terbuat dari sel kontra dan meskipun nilainya tampak sama bagi kami, filecdrbagian dari sel tidak cocok, jadi mereka tidak persis sama dengan interpreter / compiler LISP. Inilah alasannya; mengimplementasikan set besar tidak disarankan menggunakan daftar. Ini bekerja dengan baik untuk set kecil sekalipun.

Atur Persimpangan

Grup fungsi persimpangan memungkinkan Anda melakukan persimpangan pada dua daftar yang disediakan sebagai argumen untuk fungsi ini berdasarkan pengujian.

Berikut ini adalah sintaks dari fungsi-fungsi ini -

intersection list1 list2 &key :test :test-not :key 
nintersection list1 list2 &key :test :test-not :key

Fungsi ini mengambil dua daftar dan mengembalikan daftar baru yang berisi semua elemen yang ada di kedua daftar argumen. Jika salah satu daftar memiliki entri duplikat, entri yang berlebihan mungkin atau mungkin tidak muncul dalam hasil.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq set1 (intersection '(a b c) '(c d e)))
(setq set2 (intersection '(#(a b) #(5 6 7) #(f h)) 
   '(#(5 6 7) #(a b) #(g h)) :test-not #'mismatch)
)
       
(setq set3 (intersection '(#(a b) #(5 6 7) #(f h)) 
   '(#(5 6 7) #(a b) #(g h)))
)
(write set1)
(terpri)
(write set2)
(terpri)
(write set3)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(C)
(#(A B) #(5 6 7))
NIL

Fungsi interseksi adalah versi intersection dari intersection, yaitu dapat menghancurkan daftar aslinya.

Tetapkan Perbedaan

Grup fungsi set-difference memungkinkan Anda melakukan perbedaan set pada dua daftar yang disediakan sebagai argumen untuk fungsi ini berdasarkan pengujian.

Berikut ini adalah sintaks dari fungsi-fungsi ini -

set-difference list1 list2 &key :test :test-not :key 
nset-difference list1 list2 &key :test :test-not :key

Fungsi set-difference mengembalikan daftar elemen dari daftar pertama yang tidak muncul di daftar kedua.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq set1 (set-difference '(a b c) '(c d e)))
(setq set2 (set-difference '(#(a b) #(5 6 7) #(f h)) 
   '(#(5 6 7) #(a b) #(g h)) :test-not #'mismatch)
)
(setq set3 (set-difference '(#(a b) #(5 6 7) #(f h)) 
   '(#(5 6 7) #(a b) #(g h)))
)
(write set1)
(terpri)
(write set2)
(terpri)
(write set3)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(A B)
(#(F H))
(#(A B) #(5 6 7) #(F H))

Anda bisa membangun struktur data pohon dari sel kontra, sebagai daftar daftar.

Untuk mengimplementasikan struktur pohon, Anda harus mendesain fungsi yang akan melintasi sel kontra, dalam urutan tertentu, misalnya, pre-order, in-order, dan post-order untuk pohon biner.

Pohon sebagai Daftar Daftar

Mari kita pertimbangkan struktur pohon yang terdiri dari sel kontra yang membentuk daftar daftar berikut -

((1 2) (3 4) (5 6)).

Secara diagram, ini dapat dinyatakan sebagai -

Fungsi Pohon di LISP

Meskipun sebagian besar Anda perlu menulis fungsi pohon Anda sendiri sesuai dengan kebutuhan spesifik Anda, LISP menyediakan beberapa fungsi pohon yang dapat Anda gunakan.

Terlepas dari semua fungsi daftar, fungsi berikut bekerja terutama pada struktur pohon -

Sr.No.	Deskripsi fungsi
1	copy-tree x & vecp opsional Ini mengembalikan salinan pohon sel kontra x. Itu secara rekursif menyalin baik arah mobil dan cdr. Jika x bukan sel kontra, fungsi mengembalikan x tidak berubah. Jika argumen vecp opsional benar, fungsi ini menyalin vektor (secara rekursif) serta sel kontra.
2	tree-equal xy & key: test: test-not: key Ini membandingkan dua pohon sel kontra. Jika x dan y keduanya sel kontra, mobil dan cdr mereka akan dibandingkan secara rekursif. Jika x maupun y bukan sel kontra, mereka akan dibandingkan dengan persamaan, atau menurut pengujian yang ditentukan. Fungsi: key, jika ditentukan, diterapkan ke elemen dari kedua pohon.
3	subst pohon & kunci lama baru: test: test-not: key Ini menggantikan kemunculan item lama yang diberikan dengan item baru , dalam pohon , yang merupakan pohon sel kontra.
4	nsubst pohon & kunci lama baru: test: test-not: key Ia bekerja sama dengan subst, tetapi menghancurkan pohon aslinya.
5	sublis pohon alist & key: test: test-not: key Ia bekerja seperti subst, kecuali bahwa dibutuhkan sebuah asosiasi daftar alist pasangan tua-baru. Setiap elemen pohon (setelah menerapkan fungsi: key, jika ada), dibandingkan dengan mobil-mobil alist; jika cocok, itu diganti dengan cdr yang sesuai.
6	nsublis pohon alist & key: test: test-not: key Ia bekerja sama dengan sublis, tetapi versi yang merusak.

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq lst (list '(1 2) '(3 4) '(5 6)))
(setq mylst (copy-list lst))
(setq tr (copy-tree lst))

(write lst)
(terpri)
(write mylst)
(terpri)
(write tr)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

((1 2) (3 4) (5 6))
((1 2) (3 4) (5 6))
((1 2) (3 4) (5 6))

Contoh 2

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq tr '((1 2 (3 4 5) ((7 8) (7 8 9)))))
(write tr)
(setq trs (subst 7 1 tr))
(terpri)
(write trs)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

((1 2 (3 4 5) ((7 8) (7 8 9))))
((7 2 (3 4 5) ((7 8) (7 8 9))))

Membangun Pohon Anda Sendiri

Mari kita coba membangun pohon kita sendiri, menggunakan fungsi daftar yang tersedia di LISP.

Pertama mari kita buat node baru yang berisi beberapa data

(defun make-tree (item)
   "it creates a new node with item."
   (cons (cons item nil) nil)
)

Selanjutnya mari kita tambahkan simpul anak ke dalam pohon - ini akan mengambil dua simpul pohon dan menambahkan pohon kedua sebagai anak dari yang pertama.

(defun add-child (tree child)
   (setf (car tree) (append (car tree) child))
   tree)

Fungsi ini akan mengembalikan anak pertama pohon yang diberikan - ini akan mengambil simpul pohon dan mengembalikan anak pertama dari simpul itu, atau nihil, jika simpul ini tidak memiliki simpul anak.

(defun first-child (tree)
   (if (null tree)
      nil
      (cdr (car tree))
   )
)

Fungsi ini akan mengembalikan saudara berikutnya dari simpul yang diberikan - ini mengambil simpul pohon sebagai argumen, dan mengembalikan referensi ke simpul saudara berikutnya, atau nil, jika simpul tidak memilikinya.

(defun next-sibling (tree)
   (cdr tree)
)

Terakhir kita membutuhkan fungsi untuk mengembalikan informasi dalam sebuah node -

(defun data (tree)
   (car (car tree))
)

Contoh

Contoh ini menggunakan fungsi di atas -

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defun make-tree (item)
   "it creates a new node with item."
   (cons (cons item nil) nil)
)
(defun first-child (tree)
   (if (null tree)
      nil
      (cdr (car tree))
   )
)

(defun next-sibling (tree)
   (cdr tree)
)
(defun data (tree)
   (car (car tree))
)
(defun add-child (tree child)
   (setf (car tree) (append (car tree) child))
   tree
)

(setq tr '((1 2 (3 4 5) ((7 8) (7 8 9)))))
(setq mytree (make-tree 10))

(write (data mytree))
(terpri)
(write (first-child tr))
(terpri)
(setq newtree (add-child tr mytree))
(terpri)
(write newtree)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

10
(2 (3 4 5) ((7 8) (7 8 9)))

((1 2 (3 4 5) ((7 8) (7 8 9)) (10)))

Struktur data tabel hash mewakili kumpulan key-and-valuepasangan yang diatur berdasarkan kode hash kunci. Ini menggunakan kunci untuk mengakses elemen dalam koleksi.

Tabel hash digunakan saat Anda perlu mengakses elemen dengan menggunakan kunci, dan Anda dapat mengidentifikasi nilai kunci yang berguna. Setiap item dalam tabel hash memiliki pasangan kunci / nilai. Kuncinya digunakan untuk mengakses item dalam koleksi.

Membuat Tabel Hash di LISP

Dalam LISP Umum, tabel hash adalah kumpulan tujuan umum. Anda dapat menggunakan objek arbitrer sebagai kunci atau indeks.

Saat Anda menyimpan nilai dalam tabel hash, Anda membuat pasangan nilai kunci, dan menyimpannya di bawah kunci tersebut. Nanti Anda dapat mengambil nilai dari tabel hash menggunakan kunci yang sama. Setiap kunci dipetakan ke satu nilai, meskipun Anda dapat menyimpan nilai baru dalam sebuah kunci.

Tabel hash, di LISP, dapat dikategorikan menjadi tiga jenis, berdasarkan cara kunci dapat dibandingkan - eq, eql atau sama. Jika tabel hash di-hash pada objek LISP maka kuncinya dibandingkan dengan eq atau eql. Jika hash tabel hash pada struktur pohon, maka akan dibandingkan menggunakan persamaan.

Itu make-hash-tablefungsi digunakan untuk membuat tabel hash. Sintaks untuk fungsi ini adalah -

make-hash-table &key :test :size :rehash-size :rehash-threshold

Dimana -

• Itu key Argumen memberikan kuncinya.

• Itu :testargumen menentukan bagaimana kunci dibandingkan - harus memiliki satu dari tiga nilai # 'eq, #' eql, atau # 'sama, atau salah satu dari tiga simbol eq, eql, atau sama. Jika tidak ditentukan, eql diasumsikan.

• Itu :sizeargumen menetapkan ukuran awal tabel hash. Ini harus berupa bilangan bulat yang lebih besar dari nol.

• Itu :rehash-sizeargumen menentukan seberapa banyak untuk meningkatkan ukuran tabel hash ketika sudah penuh. Ini bisa berupa bilangan bulat yang lebih besar dari nol, yang merupakan jumlah entri yang akan ditambahkan, atau bisa berupa angka floating-point yang lebih besar dari 1, yang merupakan rasio ukuran baru dengan ukuran lama. Nilai default untuk argumen ini bergantung pada implementasi.

• Itu :rehash-thresholdargumen menentukan seberapa penuh tabel hash dapat diperoleh sebelum harus berkembang. Ini bisa berupa bilangan bulat yang lebih besar dari nol dan kurang dari: rehash-size (dalam hal ini akan diskalakan setiap kali tabel dikembangkan), atau bisa berupa angka floating-point antara nol dan 1. Nilai default untuk ini Argumennya bergantung pada implementasi.

Anda juga bisa memanggil fungsi make-hash-table tanpa argumen.

Mengambil Item dari dan Menambahkan Item ke Tabel Hash

Itu gethashfungsi mengambil item dari tabel hash dengan mencari kuncinya. Jika tidak menemukan kunci, maka ia mengembalikan nihil.

Ini memiliki sintaks berikut -

gethash key hash-table &optional default

dimana -

• key: adalah kunci terkait

• hash-table: adalah tabel hash yang akan dicari

• default: adalah nilai yang akan dikembalikan, jika entri tidak ditemukan, yaitu nihil, jika tidak ditentukan.

Itu gethash fungsi sebenarnya mengembalikan dua nilai, yang kedua adalah nilai predikat yang benar jika entri ditemukan, dan salah jika tidak ada entri yang ditemukan.

Untuk menambahkan item ke tabel hash, Anda dapat menggunakan setf berfungsi bersama dengan gethash fungsi.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq empList (make-hash-table)) 
(setf (gethash '001 empList) '(Charlie Brown))
(setf (gethash '002 empList) '(Freddie Seal)) 
(write (gethash '001 empList)) 
(terpri)
(write (gethash '002 empList))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(CHARLIE BROWN)
(FREDDIE SEAL)

Menghapus Entri

Itu remhashfungsi menghapus entri apa pun untuk kunci tertentu dalam tabel hash. Ini adalah predikat yang benar jika ada entri atau salah jika tidak ada.

Sintaks untuk fungsi ini adalah -

remhash key hash-table

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq empList (make-hash-table)) 
(setf (gethash '001 empList) '(Charlie Brown))
(setf (gethash '002 empList) '(Freddie Seal)) 
(setf (gethash '003 empList) '(Mark Mongoose)) 

(write (gethash '001 empList)) 
(terpri)
(write (gethash '002 empList)) 
(terpri)
(write (gethash '003 empList))  
(remhash '003 empList)
(terpri)
(write (gethash '003 empList))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

(CHARLIE BROWN)
(FREDDIE SEAL)
(MARK MONGOOSE)
NIL

Fungsi maphash

Itu maphash function memungkinkan Anda untuk menerapkan fungsi tertentu pada setiap key-value pair pada tabel hash.

Dibutuhkan dua argumen - fungsi dan tabel hash dan memanggil fungsi satu kali untuk setiap pasangan kunci / nilai dalam tabel hash.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(setq empList (make-hash-table)) 
(setf (gethash '001 empList) '(Charlie Brown))
(setf (gethash '002 empList) '(Freddie Seal)) 
(setf (gethash '003 empList) '(Mark Mongoose)) 

(maphash #'(lambda (k v) (format t "~a => ~a~%" k v)) empList)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

3 => (MARK MONGOOSE)
2 => (FREDDIE SEAL)
1 => (CHARLIE BROWN)

LISP umum menyediakan berbagai fungsi input-output. Kami telah menggunakan fungsi format, dan fungsi cetak untuk keluaran. Pada bagian ini, kita akan melihat beberapa fungsi input-output yang paling umum digunakan yang disediakan di LISP.

Fungsi Input

Tabel berikut menyediakan fungsi input LISP yang paling umum digunakan -

Sr.No.	Deskripsi fungsi
1	read& opsional aliran masukan eof-error-p eof-nilai rekursif-p Itu membaca dalam representasi tercetak dari objek Lisp dari input-stream, membangun objek Lisp yang sesuai, dan mengembalikan objek.
2	read-preserving-whitespace& opsional in-stream eof-error-p eof-value recursive-p Ini digunakan dalam beberapa situasi khusus di mana diinginkan untuk menentukan dengan tepat karakter apa yang menghentikan token yang diperpanjang.
3	read-line& opsional aliran masukan eof-error-p eof-nilai rekursif-p Itu berbunyi dalam baris teks yang diakhiri oleh baris baru.
4	read-char& opsional aliran masukan eof-error-p eof-nilai rekursif-p Dibutuhkan satu karakter dari input-stream dan mengembalikannya sebagai objek karakter.
5	unread-char karakter & aliran input opsional Ini menempatkan karakter yang terakhir dibaca dari input-stream, ke depan input-stream.
6	peek-char& opsional tipe intip input-stream eof-error-p eof-value recursive-p Ini mengembalikan karakter berikutnya untuk dibaca dari aliran input, tanpa benar-benar menghapusnya dari aliran input.
7	listen& aliran masukan opsional Predikatnya listen benar jika ada karakter yang segera tersedia dari input-stream, dan salah jika tidak.
8	read-char-no-hang& opsional aliran masukan eof-error-p eof-nilai rekursif-p Ini mirip dengan read-char, tetapi jika tidak mendapatkan karakter, itu tidak menunggu karakter, tetapi segera mengembalikan nol.
9	clear-input& aliran masukan opsional Ini membersihkan semua input buffer yang terkait dengan input-stream.
10	read-from-string string & opsional eof-error-p eof-nilai & kunci: mulai: akhir: pertahankan-spasi Ini mengambil karakter string secara berurutan dan membangun objek LISP dan mengembalikan objek tersebut. Ini juga mengembalikan indeks dari karakter pertama dalam string yang tidak dibaca, atau panjang string (atau, panjang +1), seperti yang mungkin terjadi.
11	parse-integer string & key: start: end: radix: junk-Allowed Ini memeriksa substring dari string yang dibatasi oleh: start dan: end (default ke awal dan akhir string). Ini melompati karakter spasi dan kemudian mencoba untuk mengurai integer.
12	read-byte arus masukan biner & nilai eof-error-p opsional Itu membaca satu byte dari aliran input-biner dan mengembalikannya dalam bentuk integer.

Membaca Input dari Keyboard

Itu readfungsi digunakan untuk mengambil input dari keyboard. Ini mungkin tidak membutuhkan argumen apapun.

Misalnya, pertimbangkan cuplikan kode -

(write ( + 15.0 (read)))

Asumsikan pengguna memasukkan 10.2 dari Input STDIN, ia mengembalikan,

25.2

Fungsi baca membaca karakter dari aliran input dan menafsirkannya dengan parsing sebagai representasi objek Lisp.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketik kode berikut di dalamnya -

; the function AreaOfCircle
; calculates area of a circle
; when the radius is input from keyboard

(defun AreaOfCircle()
(terpri)
(princ "Enter Radius: ")
(setq radius (read))
(setq area (* 3.1416 radius radius))
(princ "Area: ")
(write area))
(AreaOfCircle)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Enter Radius: 5 (STDIN Input)
Area: 78.53999

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(with-input-from-string (stream "Welcome to Tutorials Point!")
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (peek-char nil stream nil 'the-end))
   (values)
)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#\W 
#\e 
#\l 
#\c 
#\o 
#\m 
#\e 
#\Space 
#\t 
#\o 
#\Space

Fungsi Output

Semua fungsi output di LISP menggunakan argumen opsional yang disebut output-stream, di mana output dikirim. Jika tidak disebutkan atau nihil, aliran keluaran secara default ke nilai variabel * standard-output *.

Tabel berikut menyediakan fungsi keluaran LISP yang paling umum digunakan -

Sr.No.	Fungsi dan Deskripsi
1	write object & key: stream: escape: radix: base: circle: cantik: level: length: case: gensym: array write object & key: stream: escape: radix: base: circle: pretty: level: length: case: gensym: array: readably: margin kanan: kikir-lebar: baris: pprint-dispatch Keduanya menulis objek ke aliran keluaran yang ditentukan oleh: stream, yang secara default ke nilai * standard-output *. Nilai lain default ke variabel global terkait yang ditetapkan untuk pencetakan.
2	prin1 objek & aliran keluaran opsional print objek & aliran keluaran opsional pprint objek & aliran keluaran opsional princ objek & aliran keluaran opsional Semua fungsi ini mengeluarkan representasi tercetak dari objek ke aliran keluaran . Namun, ada perbedaan berikut - prin1 mengembalikan objek sebagai nilainya. print mencetak objek dengan baris baru sebelumnya dan diikuti dengan spasi. Ini mengembalikan objek. pprint sama seperti print kecuali spasi di belakangnya dihilangkan. princ sama seperti prin1 kecuali bahwa keluarannya tidak memiliki karakter escape
3	write-to-string objek & kunci : escape: radix: base: circle: cantik: level: length: case: gensym: array write-to-string object & key: escape: radix: base: circle: pretty: level: length: case: gensym: array: readably: right-margin: miser-width: lines: pprint-dispatch prin1-to-string obyek princ-to-string obyek Objek secara efektif dicetak dan karakter keluaran dibuat menjadi string, yang dikembalikan.
4	write-char karakter & aliran keluaran opsional Ini mengeluarkan karakter ke aliran keluaran, dan mengembalikan karakter.
5	write-string string & opsional aliran keluaran & kunci: mulai: akhir Ini menulis karakter dari substring tertentu dari string ke output-stream.
6	write-line string & opsional aliran keluaran & kunci: mulai: akhir Ini bekerja dengan cara yang sama seperti menulis-string, tetapi mengeluarkan baris baru sesudahnya.
7	terpri& arus keluaran opsional Ini mengeluarkan baris baru ke arus keluaran.
8	fresh-line& arus keluaran opsional itu mengeluarkan baris baru hanya jika aliran belum di awal baris.
9	finish-output& arus keluaran opsional force-output& arus keluaran opsional clear-output& arus keluaran opsional Fungsinya finish-output mencoba untuk memastikan bahwa semua output yang dikirim ke output-stream telah mencapai tujuannya, dan hanya mengembalikan nihil. Fungsinya force-output memulai pengosongan buffer internal apa pun tetapi mengembalikan nol tanpa menunggu penyelesaian atau pengakuan. Fungsinya clear-output mencoba untuk membatalkan setiap operasi keluaran yang sedang berlangsung untuk memungkinkan keluaran sesedikit mungkin untuk melanjutkan ke tujuan.
10	write-byte integer binary-output-stream Ini menulis satu byte, nilai integer.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

; this program inputs a numbers and doubles it
(defun DoubleNumber()
   (terpri)
   (princ "Enter Number : ")
   (setq n1 (read))
   (setq doubled (* 2.0 n1))
   (princ "The Number: ")
   (write n1)
   (terpri)
   (princ "The Number Doubled: ")
   (write doubled)
)
(DoubleNumber)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Enter Number : 3456.78 (STDIN Input)
The Number: 3456.78
The Number Doubled: 6913.56

Output Terformat

Fungsinya formatdigunakan untuk menghasilkan teks yang diformat dengan baik. Ini memiliki sintaks berikut -

format destination control-string &rest arguments

dimana,

• tujuan adalah keluaran standar
• control-string menampung karakter yang akan dikeluarkan dan petunjuk pencetakan.

SEBUAH format directive terdiri dari tilde (~), parameter awalan opsional yang dipisahkan oleh koma, pengubah titik dua opsional (:) dan at-sign (@), dan satu karakter yang menunjukkan jenis direktif ini.

Parameter awalan umumnya bilangan bulat, dinotasikan sebagai bilangan desimal bertanda opsional.

Tabel berikut memberikan penjelasan singkat tentang arahan yang umum digunakan -

Sr.No.	Petunjuk & Deskripsi
1	~A Diikuti oleh argumen ASCII.
2	~S Diikuti oleh ekspresi S.
3	~D Untuk argumen desimal.
4	~B Untuk argumen biner.
5	~O Untuk argumen oktal.
6	~X Untuk argumen heksadesimal.
7	~C Untuk argumen karakter.
8	~F Untuk argumen floating-point format tetap.
9	~E Argumen titik mengambang eksponensial.
10	~$ Argumen dolar dan floating point.
11	~% Garis baru dicetak.
12	~* Argumen berikutnya diabaikan.
13	~? Tipuan. Argumen berikutnya harus berupa string, dan argumen setelahnya berupa daftar.

Contoh

Mari kita tulis ulang program yang menghitung luas lingkaran -

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defun AreaOfCircle()
   (terpri)
   (princ "Enter Radius: ")
   (setq radius (read))
   (setq area (* 3.1416 radius radius))
   (format t "Radius: = ~F~% Area = ~F" radius area)
)
(AreaOfCircle)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Enter Radius: 10.234 (STDIN Input)
Radius: = 10.234
Area = 329.03473

Kami telah membahas tentang bagaimana input dan output standar ditangani oleh LISP umum. Semua fungsi ini berfungsi untuk membaca dan menulis ke dalam file teks dan biner juga. Satu-satunya perbedaan adalah dalam hal ini aliran yang kita gunakan bukan input atau output standar, tetapi aliran yang dibuat untuk tujuan khusus untuk menulis atau membaca dari file.

Pada bab ini kita akan melihat bagaimana LISP dapat membuat, membuka, menutup file teks atau biner untuk penyimpanan datanya.

File mewakili urutan byte, tidak masalah apakah itu file teks atau file biner. Bab ini akan memandu Anda mempelajari fungsi / makro penting untuk manajemen file.

Membuka File

Anda bisa menggunakan openberfungsi untuk membuat file baru atau membuka file yang sudah ada. Ini adalah fungsi paling dasar untuk membuka file. Namun,with-open-file biasanya lebih nyaman dan lebih umum digunakan, seperti yang akan kita lihat nanti di bagian ini.

Ketika file dibuka, objek aliran dibangun untuk mewakili itu di lingkungan LISP. Semua operasi di aliran pada dasarnya setara dengan operasi pada file.

Sintaks untuk open fungsinya adalah -

open filename &key :direction :element-type :if-exists :if-does-not-exist :external-format

dimana,

• The nama file argumen adalah nama file yang akan dibuka atau dibuat.

• The kata kunci argumen menentukan jenis aliran dan penanganan error cara.

• Itu :direction kata kunci menentukan apakah aliran harus menangani input, output, atau keduanya, dibutuhkan nilai berikut -

  • : input - untuk aliran input (nilai default)

  • : keluaran - untuk aliran keluaran

  • : io - untuk aliran dua arah

  • : probe - hanya untuk memeriksa keberadaan file; aliran dibuka dan kemudian ditutup.

• Itu :element-type menentukan jenis unit transaksi untuk aliran.

• Itu :if-existsargumen menentukan tindakan yang akan diambil jika: direction adalah: output atau: io dan file dengan nama yang ditentukan sudah ada. Jika arahnya adalah: input atau: probe, argumen ini diabaikan. Dibutuhkan nilai-nilai berikut -

  • : error - ini menandakan adanya kesalahan.

  • : versi baru - ini membuat file baru dengan nama yang sama tetapi nomor versi yang lebih besar.

  • : ganti nama - itu mengganti nama file yang ada.

  • : rename-and-delete - ini mengganti nama file yang ada dan kemudian menghapusnya.

  • : menambahkan - itu menambahkan ke file yang ada.

  • : supersede - ini menggantikan file yang ada.

  • nil - itu tidak membuat file atau bahkan aliran hanya mengembalikan nil untuk menunjukkan kegagalan.

• Itu :if-does-not-existargumen menentukan tindakan yang akan diambil jika file dengan nama yang ditentukan belum ada. Dibutuhkan nilai-nilai berikut -

  • : error - ini menandakan adanya kesalahan.

  • : buat - ini membuat file kosong dengan nama yang ditentukan dan kemudian menggunakannya.

  • nil - ia tidak membuat file atau bahkan streaming, tetapi hanya mengembalikan nil untuk menunjukkan kegagalan.

• Itu :external-format argumen menentukan skema implementasi yang diakui untuk mewakili karakter dalam file.

Misalnya, Anda dapat membuka file bernama myfile.txt yang disimpan di folder / tmp sebagai -

(open "/tmp/myfile.txt")

Menulis ke dan Membaca dari File

Itu with-open-filememungkinkan membaca atau menulis ke dalam file, menggunakan variabel aliran yang terkait dengan transaksi baca / tulis. Setelah pekerjaan selesai, secara otomatis menutup file. Sangat nyaman digunakan.

Ini memiliki sintaks berikut -

with-open-file (stream filename {options}*)
   {declaration}* {form}*

• nama file adalah nama file yang akan dibuka; bisa berupa string, nama jalur, atau aliran.

• The pilihan yang sama dengan argumen kata kunci untuk fungsi terbuka.

Contoh 1

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(with-open-file (stream "/tmp/myfile.txt" :direction :output)
   (format stream "Welcome to Tutorials Point!")
   (terpri stream)
   (format stream "This is a tutorials database")
   (terpri stream)
   (format stream "Submit your Tutorials, White Papers and Articles into our Tutorials   Directory.")
)

Harap dicatat bahwa semua fungsi input-output yang dibahas di bab sebelumnya, seperti, terpri dan format berfungsi untuk menulis ke dalam file yang kita buat di sini.

Saat Anda menjalankan kode, kode tidak mengembalikan apa pun; namun, data kami ditulis ke dalam file. Itu:direction :output kata kunci memungkinkan kami melakukan ini.

Namun, kita dapat membaca dari file ini menggunakan read-line fungsi.

Contoh 2

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(let ((in (open "/tmp/myfile.txt" :if-does-not-exist nil)))
   (when in
      (loop for line = (read-line in nil)
      
      while line do (format t "~a~%" line))
      (close in)
   )
)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Welcome to Tutorials Point!
This is a tutorials database
Submit your Tutorials, White Papers and Articles into our Tutorials Directory.

Menutup File

Itu close fungsi menutup aliran.

Struktur adalah salah satu tipe data yang ditentukan pengguna, yang memungkinkan Anda menggabungkan item data dari berbagai jenis.

Struktur digunakan untuk merepresentasikan record. Misalkan Anda ingin melacak buku Anda di perpustakaan. Anda mungkin ingin melacak atribut berikut tentang setiap buku -

• Title
• Author
• Subject
• ID Buku

Mendefinisikan Struktur

Itu defstructmakro di LISP memungkinkan Anda untuk menentukan struktur rekaman abstrak. Itudefstruct pernyataan mendefinisikan tipe data baru, dengan lebih dari satu anggota untuk program Anda.

Untuk membahas format file defstructmakro, mari kita tulis definisi struktur Buku. Kita dapat mendefinisikan struktur buku sebagai -

(defstruct book 
   title 
   author 
   subject 
   book-id 
)

Tolong dicatat

• Deklarasi di atas menciptakan struktur buku dengan empat named components. Jadi setiap buku yang dibuat akan menjadi objek struktur ini.

• Ini mendefinisikan empat fungsi bernama judul-buku, penulis-buku, subjek-buku dan id-buku-buku, yang akan mengambil satu argumen, struktur buku, dan akan mengembalikan judul bidang, penulis, subjek dan id buku dari buku tersebut obyek. Fungsi ini disebutaccess functions.

• Buku simbol menjadi tipe data dan Anda dapat memeriksanya menggunakan typep predikat.

• Juga akan ada fungsi implisit bernama book-p, yang merupakan predikat dan akan benar jika argumennya sebuah buku dan salah sebaliknya.

• Fungsi implisit lain bernama make-book akan dibuat, yaitu a constructor, yang, jika dipanggil, akan membuat struktur data dengan empat komponen, cocok untuk digunakan dengan fungsi akses.

• Itu #S syntax mengacu pada struktur, dan Anda dapat menggunakannya untuk membaca atau mencetak contoh dari sebuah buku.

• Fungsi implisit bernama copy-book dari satu argumen juga didefinisikan itu. Dibutuhkan objek buku dan membuat objek buku lain, yang merupakan salinan dari yang pertama. Fungsi ini disebutcopier function.

• Kamu dapat memakai setf untuk mengubah komponen sebuah buku, misalnya

(setf (book-book-id book3) 100)

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defstruct book 
   title 
   author 
   subject 
   book-id 
)

( setq book1 (make-book :title "C Programming"
   :author "Nuha Ali" 
   :subject "C-Programming Tutorial"
   :book-id "478")
)

( setq book2 (make-book :title "Telecom Billing"
   :author "Zara Ali" 
   :subject "C-Programming Tutorial"
   :book-id "501")
) 

(write book1)
(terpri)
(write book2)
(setq book3( copy-book book1))
(setf (book-book-id book3) 100) 
(terpri)
(write book3)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

#S(BOOK :TITLE "C Programming" :AUTHOR "Nuha Ali" :SUBJECT "C-Programming Tutorial" :BOOK-ID "478")
#S(BOOK :TITLE "Telecom Billing" :AUTHOR "Zara Ali" :SUBJECT "C-Programming Tutorial" :BOOK-ID "501")
#S(BOOK :TITLE "C Programming" :AUTHOR "Nuha Ali" :SUBJECT "C-Programming Tutorial" :BOOK-ID 100)

Dalam istilah umum bahasa pemrograman, sebuah paket dirancang untuk menyediakan cara untuk memisahkan satu set nama dari yang lain. Simbol yang dideklarasikan dalam satu paket tidak akan bertentangan dengan simbol yang sama yang dideklarasikan di paket lainnya. Dengan cara ini paket mengurangi konflik penamaan antara modul kode independen.

Pembaca LISP menyimpan tabel semua simbol yang ditemukannya. Ketika menemukan urutan karakter baru, itu membuat simbol baru dan disimpan di tabel simbol. Tabel ini disebut paket.

Paket saat ini dirujuk oleh variabel khusus * paket *.

Ada dua paket standar di LISP -

• common-lisp - ini berisi simbol untuk semua fungsi dan variabel yang ditentukan.

• common-lisp-user- menggunakan paket common-lisp dan semua paket lainnya dengan alat pengeditan dan debugging; singkatnya disebut cl-user

Fungsi Paket di LISP

Tabel berikut menyediakan fungsi yang paling umum digunakan untuk membuat, menggunakan, dan memanipulasi paket -

Sr.No.	Fungsi dan Deskripsi
1	make-package package-name & key: nicknames: use Ini membuat dan mengembalikan paket baru dengan nama paket yang ditentukan.
2	in-package package-name & key: nicknames: use Membuat paket saat ini.
3	in-package nama Makro ini menyebabkan * paket * disetel ke nama paket nama, yang harus berupa simbol atau string.
4	find-package nama Ini mencari paket. Paket dengan nama atau julukan itu dikembalikan; jika tidak ada paket seperti itu, find-package mengembalikan nil.
5	rename-package paket nama baru & nama panggilan baru opsional itu mengganti nama paket.
6	list-all-packages Fungsi ini mengembalikan daftar semua paket yang saat ini ada di sistem Lisp.
7	delete-package paket Ini menghapus sebuah paket.

Membuat Paket LISP

Itu defpackagefungsi digunakan untuk membuat paket yang ditentukan pengguna. Ini memiliki sintaks berikut -

(defpackage :package-name
   (:use :common-lisp ...)
   (:export :symbol1 :symbol2 ...)
)

Dimana,

• nama-paket adalah nama paket.

• Kata kunci: use menentukan paket yang dibutuhkan paket ini, yaitu paket yang mendefinisikan fungsi yang digunakan oleh kode dalam paket ini.

• Kata kunci: export menentukan simbol yang berada di luar paket ini.

Itu make-packagefungsi juga digunakan untuk membuat paket. Sintaks untuk fungsi ini adalah -

make-package package-name &key :nicknames :use

argumen dan kata kunci memiliki arti yang sama seperti sebelumnya.

Menggunakan Package

Setelah Anda membuat paket, Anda dapat menggunakan kode dalam paket ini, dengan menjadikannya paket saat ini. Ituin-package makro membuat paket terkini di lingkungan.

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(make-package :tom)
(make-package :dick)
(make-package :harry)
(in-package tom)
(defun hello () 
   (write-line "Hello! This is Tom's Tutorials Point")
)

(hello)
(in-package dick)
(defun hello () 
   (write-line "Hello! This is Dick's Tutorials Point")
)

(hello)
(in-package harry)
(defun hello () 
   (write-line "Hello! This is Harry's Tutorials Point")
)

(hello)
(in-package tom)
(hello)
(in-package dick)
(hello)
(in-package harry)
(hello)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Hello! This is Tom's Tutorials Point
Hello! This is Dick's Tutorials Point
Hello! This is Harry's Tutorials Point

Menghapus Paket

Itu delete-packagemakro memungkinkan Anda untuk menghapus sebuah paket. Contoh berikut menunjukkan ini -

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(make-package :tom)
(make-package :dick)
(make-package :harry)
(in-package tom)
(defun hello () 
   (write-line "Hello! This is Tom's Tutorials Point")
)

(in-package dick)
(defun hello () 
   (write-line "Hello! This is Dick's Tutorials Point")
)

(in-package harry)
(defun hello () 
   (write-line "Hello! This is Harry's Tutorials Point")
)

(in-package tom)
(hello)
(in-package dick)
(hello)
(in-package harry)
(hello)
(delete-package tom)
(in-package tom)
(hello)

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Hello! This is Tom's Tutorials Point
Hello! This is Dick's Tutorials Point
Hello! This is Harry's Tutorials Point
*** - EVAL: variable TOM has no value

Dalam terminologi LISP umum, pengecualian disebut kondisi.

Faktanya, kondisi lebih umum daripada pengecualian dalam bahasa pemrograman tradisional, karena a condition mewakili setiap kejadian, kesalahan, atau tidak, yang mungkin mempengaruhi berbagai tingkat tumpukan panggilan fungsi.

Mekanisme penanganan kondisi di LISP, menangani situasi tersebut sedemikian rupa sehingga kondisi digunakan untuk memberi sinyal peringatan (misalnya dengan mencetak peringatan) sementara kode tingkat atas pada tumpukan panggilan dapat melanjutkan pekerjaannya.

Sistem penanganan kondisi di LISP memiliki tiga bagian -

• Menandakan suatu kondisi
• Penanganan kondisi
• Mulai ulang prosesnya

Menangani Kondisi

Mari kita ambil contoh penanganan kondisi yang timbul dari kondisi bagi dengan nol, untuk menjelaskan konsepnya di sini.

Anda perlu mengambil langkah-langkah berikut untuk menangani suatu kondisi -

• Define the Condition - "Kondisi adalah objek yang kelasnya menunjukkan sifat umum dari kondisi dan data contoh yang membawa informasi tentang rincian keadaan tertentu yang mengarah ke kondisi yang diberi sinyal".

  Makro definisikan kondisi digunakan untuk menentukan kondisi, yang memiliki sintaks berikut -

  (define-condition condition-name (error)
     ((text :initarg :text :reader text))
  )

  Objek kondisi baru dibuat dengan makro MAKE-CONDITION, yang menginisialisasi slot kondisi baru berdasarkan :initargs argumen.

  Dalam contoh kami, kode berikut mendefinisikan kondisi -

  (define-condition on-division-by-zero (error)
     ((message :initarg :message :reader message))
  )

• Writing the Handlers- pengendali kondisi adalah kode yang digunakan untuk menangani kondisi yang ditandai di atasnya. Ini umumnya ditulis di salah satu fungsi tingkat yang lebih tinggi yang memanggil fungsi kesalahan. Ketika sebuah kondisi diberi sinyal, mekanisme pensinyalan mencari penangan yang sesuai berdasarkan kelas kondisi tersebut.

  Setiap penangan terdiri dari -

  • Type specifier, yang menunjukkan jenis kondisi yang dapat ditangani
  • Fungsi yang membutuhkan satu argumen, kondisi

  Ketika suatu kondisi diberi sinyal, mekanisme pensinyalan menemukan penangan yang paling baru dibuat yang kompatibel dengan tipe kondisi dan memanggil fungsinya.

  Makro handler-casemenetapkan penangan kondisi. Bentuk dasar handler-case -

  (handler-case expression error-clause*)

  Di mana, setiap klausa kesalahan berbentuk -

  condition-type ([var]) code)

• Restarting Phase

  Ini adalah kode yang benar-benar memulihkan program Anda dari kesalahan, dan penangan kondisi kemudian dapat menangani kondisi dengan menjalankan restart yang sesuai. Kode restart umumnya ditempatkan di fungsi tingkat menengah atau tingkat rendah dan penangan kondisi ditempatkan di tingkat atas aplikasi.

  Itu handler-bindmakro memungkinkan Anda untuk menyediakan fungsi restart, dan memungkinkan Anda untuk melanjutkan di fungsi tingkat yang lebih rendah tanpa melepaskan tumpukan panggilan fungsi. Dengan kata lain, aliran kendali akan tetap berada di fungsi level bawah.

  Bentuk dasar handler-bind adalah sebagai berikut -

  (handler-bind (binding*) form*)

  Di mana setiap pengikatan adalah daftar berikut -

  • tipe kondisi
  • fungsi penangan dari satu argumen

  Itu invoke-restart macro menemukan dan memanggil fungsi restart terikat terbaru dengan nama yang ditentukan sebagai argumen.

  Anda dapat memulai ulang berkali-kali.

Contoh

Dalam contoh ini, kami mendemonstrasikan konsep di atas dengan menulis fungsi bernama fungsi-divisi, yang akan membuat kondisi kesalahan jika argumen pembagi adalah nol. Kami memiliki tiga fungsi anonim yang menyediakan tiga cara untuk keluar darinya - dengan mengembalikan nilai 1, dengan mengirimkan pembagi 2 dan menghitung ulang, atau dengan mengembalikan 1.

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(define-condition on-division-by-zero (error)
   ((message :initarg :message :reader message))
)
   
(defun handle-infinity ()
   (restart-case
      (let ((result 0))
         (setf result (division-function 10 0))
         (format t "Value: ~a~%" result)
      )
      (just-continue () nil)
   )
)
     
(defun division-function (value1 value2)
   (restart-case
      (if (/= value2 0)
         (/ value1 value2)
         (error 'on-division-by-zero :message "denominator is zero")
      )

      (return-zero () 0)
      (return-value (r) r)
      (recalc-using (d) (division-function value1 d))
   )
)

(defun high-level-code ()
   (handler-bind
      (
         (on-division-by-zero
            #'(lambda (c)
               (format t "error signaled: ~a~%" (message c))
               (invoke-restart 'return-zero)
            )
         )
         (handle-infinity)
      )
   )
)

(handler-bind
   (
      (on-division-by-zero
         #'(lambda (c)
            (format t "error signaled: ~a~%" (message c))
            (invoke-restart 'return-value 1)
         )
      )
   )
   (handle-infinity)
)

(handler-bind
   (
      (on-division-by-zero
         #'(lambda (c)
            (format t "error signaled: ~a~%" (message c))
            (invoke-restart 'recalc-using 2)
         )
      )
   )
   (handle-infinity)
)

(handler-bind
   (
      (on-division-by-zero
         #'(lambda (c)
            (format t "error signaled: ~a~%" (message c))
            (invoke-restart 'just-continue)
         )
      )
   )
   (handle-infinity)
)

(format t "Done."))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

error signaled: denominator is zero
Value: 1
error signaled: denominator is zero
Value: 5
error signaled: denominator is zero
Done.

Selain 'Sistem Kondisi', seperti dibahas di atas, LISP Umum juga menyediakan berbagai fungsi yang mungkin dipanggil untuk menandakan kesalahan. Penanganan kesalahan, ketika diberi tanda, bagaimanapun, tergantung pada implementasi.

Fungsi Pemberian Sinyal Kesalahan di LISP

Tabel berikut menyediakan fungsi yang umum digunakan memberi sinyal peringatan, jeda, kesalahan non-fatal dan fatal.

Program pengguna menentukan pesan kesalahan (string). Fungsi memproses pesan ini dan mungkin / mungkin tidak menampilkannya kepada pengguna.

Pesan kesalahan harus dibuat dengan menerapkan format fungsi, tidak boleh mengandung karakter baris baru di awal atau akhir, dan tidak perlu menunjukkan kesalahan, karena sistem LISP akan menangani ini sesuai dengan gaya yang disukai.

Sr.No.	Fungsi dan Deskripsi
1	error format-string & rest args Ini menandakan kesalahan fatal. Tidak mungkin melanjutkan kesalahan semacam ini; dengan demikian kesalahan tidak akan pernah kembali ke pemanggilnya.
2	cerror lanjutkan-format-string error-format-string & rest args Ini menandakan kesalahan dan memasuki debugger. Namun, ini memungkinkan program dilanjutkan dari debugger setelah mengatasi kesalahan.
3	warn format-string & rest args itu mencetak pesan kesalahan tetapi biasanya tidak masuk ke debugger
4	break& format-string opsional & argumen istirahat Ini mencetak pesan dan langsung masuk ke debugger, tanpa membiarkan kemungkinan intersepsi oleh fasilitas penanganan kesalahan yang diprogram

Contoh

Dalam contoh ini, fungsi faktorial menghitung faktorial sebuah angka; Namun, jika argumennya negatif, hal itu menimbulkan kondisi kesalahan.

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defun factorial (x)
   (cond ((or (not (typep x 'integer)) (minusp x))
      (error "~S is a negative number." x))
      ((zerop x) 1)
      (t (* x (factorial (- x 1))))
   )
)

(write(factorial 5))
(terpri)
(write(factorial -1))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

120
*** - -1 is a negative number.

LISP umum mendahului kemajuan pemrograman berorientasi objek selama beberapa dekade. Namun, orientasi objek telah dimasukkan ke dalamnya pada tahap selanjutnya.

Mendefinisikan Kelas

Itu defclassmakro memungkinkan pembuatan kelas yang ditentukan pengguna. Ini menetapkan kelas sebagai tipe data. Ini memiliki sintaks berikut -

(defclass class-name (superclass-name*)
   (slot-description*)
   class-option*))

Slot adalah variabel yang menyimpan data, atau bidang.

Deskripsi slot memiliki bentuk (slot-name slot-option *), di mana setiap opsi adalah kata kunci yang diikuti dengan nama, ekspresi, dan opsi lainnya. Opsi slot yang paling umum digunakan adalah -

• :accessor nama-fungsi

• :initform ekspresi

• :initarg simbol

Sebagai contoh, mari kita tentukan kelas Box, dengan tiga slot panjang, lebar, dan tinggi.

(defclass Box () 
   (length 
   breadth 
   height)
)

Menyediakan Akses dan Kontrol Baca / Tulis ke Slot

Kecuali jika slot memiliki nilai yang dapat diakses, dibaca atau ditulis, kelas akan sangat tidak berguna.

Anda bisa menentukan accessorsuntuk setiap slot saat Anda menentukan kelas. Misalnya, ambil kelas Box kami -

(defclass Box ()
   ((length :accessor length)
      (breadth :accessor breadth)
      (height :accessor height)
   )
)

Anda juga dapat menentukan secara terpisah accessor nama untuk membaca dan menulis slot.

(defclass Box ()
   ((length :reader get-length :writer set-length)
      (breadth :reader get-breadth :writer set-breadth)
      (height :reader get-height :writer set-height)
   )
)

Membuat Instance dari Kelas

Fungsi generik make-instance membuat dan mengembalikan instance baru dari kelas.

Ini memiliki sintaks berikut -

(make-instance class {initarg value}*)

Contoh

Mari kita buat kelas Box, dengan tiga slot, panjang, lebar dan tinggi. Kami akan menggunakan tiga aksesor slot untuk mengatur nilai di bidang ini.

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defclass box ()
   ((length :accessor box-length)
      (breadth :accessor box-breadth)
      (height :accessor box-height)
   )
)
(setf item (make-instance 'box))
(setf (box-length item) 10)
(setf (box-breadth item) 10)
(setf (box-height item) 5)
(format t "Length of the Box is ~d~%" (box-length item))
(format t "Breadth of the Box is ~d~%" (box-breadth item))
(format t "Height of the Box is ~d~%" (box-height item))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Length of the Box is 10
Breadth of the Box is 10
Height of the Box is 5

Mendefinisikan Metode Kelas

Itu defmethodmakro memungkinkan Anda untuk menentukan metode di dalam kelas. Contoh berikut memperluas kelas Box kami untuk menyertakan metode bernama volume.

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defclass box ()
   ((length :accessor box-length)
      (breadth :accessor box-breadth)
      (height :accessor box-height)
      (volume :reader volume)
   )
)

; method calculating volume   

(defmethod volume ((object box))
   (* (box-length object) (box-breadth object)(box-height object))
)

 ;setting the values 

(setf item (make-instance 'box))
(setf (box-length item) 10)
(setf (box-breadth item) 10)
(setf (box-height item) 5)

; displaying values

(format t "Length of the Box is ~d~%" (box-length item))
(format t "Breadth of the Box is ~d~%" (box-breadth item))
(format t "Height of the Box is ~d~%" (box-height item))
(format t "Volume of the Box is ~d~%" (volume item))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Length of the Box is 10
Breadth of the Box is 10
Height of the Box is 5
Volume of the Box is 500

Warisan

LISP memungkinkan Anda untuk mendefinisikan suatu objek dalam kaitannya dengan objek lain. Ini disebutinheritance.Anda dapat membuat kelas turunan dengan menambahkan fitur yang baru atau berbeda. Kelas turunan mewarisi fungsionalitas dari kelas induk.

Contoh berikut menjelaskan ini -

Contoh

Buat file kode sumber baru bernama main.lisp dan ketikkan kode berikut di dalamnya.

(defclass box ()
   ((length :accessor box-length)
      (breadth :accessor box-breadth)
      (height :accessor box-height)
      (volume :reader volume)
   )
)

; method calculating volume   
(defmethod volume ((object box))
   (* (box-length object) (box-breadth object)(box-height object))
)
  
;wooden-box class inherits the box class  
(defclass wooden-box (box)
((price :accessor box-price)))

;setting the values 
(setf item (make-instance 'wooden-box))
(setf (box-length item) 10)
(setf (box-breadth item) 10)
(setf (box-height item) 5)
(setf (box-price item) 1000)

; displaying values
(format t "Length of the Wooden Box is ~d~%" (box-length item))
(format t "Breadth of the Wooden Box is ~d~%" (box-breadth item))
(format t "Height of the Wooden Box is ~d~%" (box-height item))
(format t "Volume of the Wooden Box is ~d~%" (volume item))
(format t "Price of the Wooden Box is ~d~%" (box-price item))

Saat Anda menjalankan kode, ia mengembalikan hasil berikut -

Length of the Wooden Box is 10
Breadth of the Wooden Box is 10
Height of the Wooden Box is 5
Volume of the Wooden Box is 500
Price of the Wooden Box is 1000