Teşekkürler güzel cevaplar için çok fazla! Doğru olarak sadece bir işareti

Not: Zaten bir wiki

Fonksiyonel programlama yeni ve ben Fonksiyonel programlama basit işlevleri, bir sayının faktöriyel hesaplama örneğin okuyabilirim olsa da, zor büyük işlevleri buluyorum. Bu yüzden bence, çünkü benim yetersizlik anlamak daha küçük kod blokları içinde bir işlev tanımı ve ayrıca kısmen çünkü olmak zor benim için Maç ( ) kodu.

Eğer birileri bazı kod okuma bana yol göster ve bana hızlı bir şekilde bazı şifreleri " ni çözmek için bazı ipuçları verebilir eğer çok iyi olurdu.

Not: Eğer bakarsam bu kod 10 dakika anlayabiliyorum, ama eğer bu aynı kod Java ile yazılmış olsaydı, bana 10 dakika süreceğini sanmam. Lisp tarzı kod içinde rahat hissetmek sanırım çok daha hızlı yapmak zorundayım

Not: bu öznel bir soru olduğunu biliyorum. Ve burada kanıtlanabilir herhangi bir doğru cevap isteyen değilim. Bu kodu okuma hakkında gitmek nasıl sadece yorum, karşılama ve son derece yararlı olacaktır

(defn concat
  ([] (lazy-seq nil))
  ([x] (lazy-seq x))
  ([x y]
    (lazy-seq
      (let [s (seq x)]
        (if s
          (if (chunked-seq? s)
            (chunk-cons (chunk-first s) (concat (chunk-rest s) y))
            (cons (first s) (concat (rest s) y)))
          y))))
  ([x y & zs]
     (let [cat (fn cat [xys zs]
                 (lazy-seq
                   (let [xys (seq xys)]
                     (if xys
                       (if (chunked-seq? xys)
                         (chunk-cons (chunk-first xys)
                                     (cat (chunk-rest xys) zs))
                         (cons (first xys) (cat (rest xys) zs)))
                       (when zs
                         (cat (first zs) (next zs)))))))]
       (cat (concat x y) zs))))

concat anlamak için denemek için kötü bir örnek olduğunu düşünüyorum. Temel bir işlevi var ve normalde verimli olması için çaba çünkü Kendin yaz, ne olur Daha fazla kod daha düşük seviyede.

Akılda tutulması gereken bir diğer şey Clojure kod Java kod kıyasla son derece yoğun olması. Küçük Clojure bir kod çok iş yapar. Java aynı kod 23 çizgiler olmaz. Büyük olasılıkla birden fazla sınıflar ve arabirimler, pek çok yöntem,-atın değişkenler ve garip döngü yapıları yerel geçici bir sürü demirbaş ve her türlü genellikle olur.

Bazı genel ipuçları olsa da...

1. Bu parens çoğu zaman görmezden gelmeye çalışın. Girinti yerine Nathan Sanders da anlaşılacağı gibi) kullanın. örneğin

   (if s
     (if (chunked-seq? s)
       (chunk-cons (chunk-first s) (concat (chunk-rest s) y))
       (cons (first s) (concat (rest s) y)))
     y))))
   

   Buna baktığım zaman beynim görür:

   if foo
     then if bar
       then baz
       else quux
     else blarf
   

2. Bir paren üzerinde imleci koymak ve metin editörü sözdizimi-vurgulama eşleşen bir yaramazsa, yeni bir editör bulmanı öneririm.

3. Bazen kod içeride-dışarıda okumak daha kolay olur. Clojure kodu içiçe olma eğilimindedir.

   (let [xs (range 10)]
     (reverse (map #(/ % 17) (filter (complement even?) xs))))
   

   Kötü:"10'a kadar 1 Sayı ile başlıyoruz. Sonra bekleme teşekkürler, ben neden bahsettiğimi unuttum filtreleme eşleştirme sırasını ters ediyoruz."

   İyi:"TAMAM, bu kadar xs bazı götürüyoruz. (complement even?) hatta tam tersi anlamına gelir,"". garip yani Sadece tek sayılar kalır bu yüzden bazı toplama filtreleme ediyoruz. Sonra onları 17 bölen tek şey biziz. Sonra onların sırasını ters ediyoruz. Ve söz konusu xs 10, yakaladım 1."

   Bazen bu açıkça bunu yapmak için yardımcı olur. Ara sonuçlarını almak, let onları atmak ve onları anlamak için bir isim verin. ÇOĞALTMA bu gibi oynamak için yapılır. Ara sonuçları ve her adım ne verir bakın yürütmek.

   (let [xs (range 10)
         odd? (complement even?)
         odd-xs (filter odd? xs)
         odd-xs-over-17 (map #(/ % 17) odd-xs)
         reversed-xs (reverse odd-xs-over-17)]
     reversed-xs)
   

   Yakında bu tür bir şey zihinsel bir çaba olmadan yapmak mümkün olacak.

4. (doc) serbest kullanılmasını sağlamak. Belge ÇOĞALTMA sağda mevcut sahip yararı göz ardı edilemez. clojure.contrib.repl-utils seçeneğini kullanın .sınıf dosyaları clj, (source some-function) yapın ve tüm kaynak kodunu görebilirsiniz. (show some-java-class) ve tüm yöntemleri bir açıklama görebilirsiniz. Ve benzeri.

Bir şeyi hızlı bir şekilde okumak için güçlü olmak, ancak deneyimi sunuyor. Lisp başka bir dil daha okumak için daha zordur. Sadece en dilleri C gibi görünen çok olur, ve çoğu programcı çoğu zaman, bu yüzden C sözdizimi okumak daha kolay gibi görünüyor okuma harcamak. Pratik pratik pratik.