Bagaimana cara menulis Kode Clojure yang dapat dibaca?

Saya baru di Clojure. Saya dapat memahami kode yang saya tulis tetapi menjadi terlalu sulit untuk memahaminya nanti.
Menjadi sulit untuk mencocokkan tanda kurung.

Apa konvensi umum yang harus diikuti mengenai konvensi penamaan dan indentasi dalam berbagai situasi?

Sebagai contoh saya menulis contoh de-struktur contoh untuk memahami tetapi kelihatannya benar-benar tidak dapat dibaca untuk kedua kalinya.

(defn f [{x :x y :y z :z [a b c] :coll}] (print x " " y  " " z " " a " " b " " c)) 

Dalam kasus de-structuring, apakah lebih baik melakukannya langsung di tingkat parameter atau memulai formulir let lalu lanjutkan ke sana?

Konvensi penamaan

• tinggal huruf kecil untuk fungsi

• gunakan -untuk tanda hubung (apa yang akan menjadi garis bawah atau kasus unta dalam bahasa lain).

  (defn add-one [i] (inc i))

• Predikat (yaitu fungsi yang mengembalikan benar atau salah) diakhiri dengan ? Contoh:odd? even? nil? empty?

• Prosedur perubahan negara diakhiri dengan !. Anda ingat set!kan? atauswap!

• Pilih panjang nama variabel pendek tergantung pada jangkauannya. Itu berarti jika Anda memiliki variabel bantu yang sangat kecil, Anda seringkali dapat menggunakan nama satu huruf. (map (fn [[k v]] (inc v)) {:test 4 :blub 5})pilih nama variabel yang lebih panjang sesuai kebutuhan, terutama jika mereka digunakan untuk banyak baris kode dan Anda tidak dapat langsung menebak tujuannya. (pendapat saya).

  Saya merasa bahwa banyak programmer clojure cenderung menggunakan nama generik dan pendek. Tapi ini tentu saja bukan observasi objektif. Intinya adalah bahwa banyak fungsi clojure sebenarnya cukup generik.

  • Gunakan nama yang bermakna. Prosedur sedang melakukan sesuatu, oleh karena itu Anda bisa menggambarkannya dengan menggunakan kata kerja. Clojure fungsi built-in harus menempatkan Anda di jalur yang benar: drop, take, assoc, dll Lalu ada artikel bagus yang menjelaskan cara untuk memilih nama yang bermakna: http://ecmendenhall.github.io/blog/blog/2013/09/ 02 / clean-clojure-bermakna-nama /

Fungsi Lambda

• Anda sebenarnya dapat memberi nama fungsi lambda. Ini nyaman untuk debugging dan profil (pengalaman saya di sini adalah dengan ClojureScript).

  (fn square-em [[k v]] {k (* v v)})

• Gunakan fungsi lambda sebaris senyaman #()mungkin

Ruang putih

• Seharusnya tidak ada garis paren saja. Yaitu, tutup kurung segera. Ingat parens ada untuk editor dan kompiler, lekukan untuk Anda.

• Daftar parameter fungsi menuju baris baru

   (defn kontra
     [ab]
     (daftar ab))

Ini masuk akal jika Anda berpikir tentang string dokumen. Mereka berada di antara nama fungsi dan parameter. String doc berikut ini mungkin bukan yang paling bijaksana;)

   (defn kontra
     "Mempasangkan hal-hal"
     [ab]
     (daftar ab))

• Data yang dipasangkan dapat dipisahkan oleh baris baru selama Anda mempertahankan pasangan tersebut

  (defn f 
    [{x: x 
      Y y 
      z: z  
      [abc]: coll}] 
    (cetak x "" y "" z "" a "" b "" c)) 

(Anda juga dapat masuk ,sesuka Anda tetapi ini terasa tidak suram).

• Untuk indentasi gunakan editor yang cukup bagus. Bertahun-tahun yang lalu ini adalah emacs untuk mengedit lisp, vim juga bagus hari ini. IDE clojure yang khas juga harus menyediakan fungsionalitas ini. Hanya saja, jangan gunakan editor teks acak.

  Dalam vim dalam mode perintah, Anda dapat menggunakan =perintah untuk membuat indentasi dengan benar.

• Jika perintah terlalu panjang (bersarang, dll.) Anda dapat memasukkan baris baru setelah argumen pertama. Sekarang kode berikut ini cukup tidak masuk akal tetapi menggambarkan bagaimana Anda dapat mengelompokkan dan membuat indentasi:

(+ (if-let [usia (: coll usia pribadi)]
     (jika (> usia 18)
       usia
       0))
   (hitung (rentang (- 3 b)
                 (kurangi + 
                         (rentang b 10)))))

Lekukan yang baik berarti Anda tidak perlu menghitung tanda kurung. Tanda kurung adalah untuk komputer (untuk menafsirkan kode sumber dan untuk indentasi itu). Lekukan untuk memudahkan Anda memahami.

Fungsi fordan doseqbentuk orde tinggi

Berasal dari latar belakang Skema, saya agak bangga telah memahami mapfungsi dan lambda, dll. Jadi cukup sering, saya akan menulis sesuatu seperti ini

(map (fn [[k x]] (+ x (k data))) {:a 10 :b 20 :c 30})

Ini sulit dibaca. The forBentuk adalah cara yang lebih baik:

(for [[k x] {:a 10 :b 20 :c30}]
  (+ x (k data)))

`map memiliki banyak kegunaan dan sangat bagus jika Anda menggunakan fungsi-fungsi yang disebutkan. Yaitu

(map inc [12 30 10]

(map count [[10 20 23] [1 2 3 4 5] (range 5)])

Gunakan Threading macro

Gunakan makro threading ->dan ->>juga dotojika berlaku.

Intinya adalah bahwa threading macro membuat kode sumber tampak lebih linier daripada komposisi fungsi. Sepotong kode berikut ini tidak dapat dibaca tanpa makro threading:

   (f (g (h 3) 10) [10 3 2 3])

dibandingkan dengan

   (-> 
     (h 3)
     (g 10)
     (f [10 3 2 3]))

Dengan menggunakan threading macro, seseorang biasanya dapat menghindari memperkenalkan variabel sementara yang hanya digunakan sekali.

Hal-hal lain

• Gunakan dokumen
• menjaga fungsi singkat
• baca kode clojure lainnya