Как узнать, когда нужно переходить на новую строку в Clojure / Lisp в целом?

Question

Вот пример кода:

(deftype Deck52 [suits] :as this
  DeckOfCards
  (check-empty []
               (Deck52. (apply hash-map 
                              (apply concat (remove (-> nil?) 
                                                    (for [[key val] suits] 
                                                      (if (empty? val) nil [key val])))))))
  (remove-card [suit card]
               (assoc suits suit (remove #(= card %) (suit suits))))

  (get-card [suit]
            (let [suitd (suit suits)]
              [(first suitd) (check-empty (Deck52. (assoc suits suit (rest suitd))))]))

  (random-card []
               (let [suitn (+ 1 (rand-int 4))]
                 (cond (= suitn 1) (get-card this :hearts)
                       (= suitn 2) (get-card this :diamonds)
                       (= suitn 3) (get-card this :clubs)
                       (= suitn 4) (get-card this :spades)))))

Я также разместил этот код в Gist здесь, если его легче читать: http://gist.github.com/307425 (никуда не денется).

Основной пример здесь check-empty. Мне было очень трудно знать, где я должен и не должен нажимать «вернуться», и я до сих пор не знаю, правильно ли я это сделал. Это грозит пройти прямо с правой стороны экрана, но это способ отступа в режиме Clojure, и я предполагаю, что так и должно быть.

Итак, вопрос в том, когда пора помещать новую строку в код Clojure / Lisp? Я делаю это обряд?

ПРИМЕЧАНИЕ: я не могу обещать, что код, который я разместил, работает. Я проводил некоторые эксперименты, и некоторые вещи могли бы быть просто отстойными, если не сломаны.

Answer 1

То, как вы сломали линии, вполне нормально. Я хотел бы сделать небольшие изменения.

• Поместите векторы аргументов в следующую строку.
• Используйте разные формы: маленькие -> и ->> помощники, condp, когда, ...
• При необходимости разорвите строку сразу после имени функции.

Вот как бы я поступил по этому поводу. (Отказ от ответственности: Мой стиль. Ваш может быть другим. YMMV!)

(deftype Deck52 [suits] :as this
  DeckOfCards
  (check-empty
    []
    (->> (for [[key val] suits]
           (when-not (empty? val)
             [key val]))
      (remove nil?)
      (apply concat)
      (apply hash-map)
      Deck52.))
  (remove-card
    [suit card]
    (assoc suits suit (remove #(= card %) (suit suits))))
  (get-card
    [suit]
    (let [suitd (suit suits)]
      [(first suitd)
       (->> (rest suitd)
         (assoc suits suit)
         Deck52.
         check-empty)]))
  (random-card
    []
    (let [suitn (+ 1 (rand-int 4))]
      (condp = suitn
        1 (get-card this :hearts)
        2 (get-card this :diamonds)
        3 (get-card this :clubs)
        4 (get-card this :spades)))))

Хотя следующее не является частью вашего вопроса, я не могу удержаться:

(deftype Deck52 [suits] :as this
  DeckOfCards
  (check-empty
    []
    (->> suits (remove (comp nil? seq val)) (into {}) Deck52.))
  (remove-card
    [suit card]
    (update-in suits [suit] #(remove %2 %1) #(= card %)))
  (get-card
    [suit]
    (let [suitd (get suits suit)]
      [(first suitd)
       (->> (rest suitd) (assoc suits suit) Deck52. check-empty)]))
  (random-card
    []
    (case (rand-int 4)
      0 (get-card this :hearts)
      1 (get-card this :diamonds)
      2 (get-card this :clubs)
      3 (get-card this :spades))))

Answer 2

clojure-mode для Emacs не обязательно делает все отступы правильными. Я говорю, постарайтесь, чтобы ваши строки были длиной до 80 символов и были последовательными.

Answer 3

когда вещи пытаются сбежать с правой стороны, я склоняюсь к его вводу после первого аргумента каждого вызова.это только отступы на фиксированную сумму в строке.

(check-empty []
             (Deck52. 
              (apply 
               hash-map 
               (apply 
                concat 
                (remove 
                 (-> 
                  nil?) 
                  (for [[key val] suits] 
                   (if (empty? val) nil [key val])))))))