¿Cómo se sabe cuándo volver a introducirse en Clojure/Lisp en general?

Question

Aquí es un poco de código de ejemplo:

(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))))) 

También he publicado este código en un Gist aquí si es más fácil de leer: http://gist.github.com/307425 (no ir a ninguna parte).

El primer ejemplo aquí es check-empty. Tuve gran dificultad para saber dónde debería y no debo presionar regresar, y todavía no sé si lo hice bien. Amenaza con salir directamente del lado derecho de la pantalla, pero esa es la forma en que el modo clojure modela, y supongo que se supone que es así.

Entonces, la pregunta es, ¿cuándo es hora de colocar una nueva línea en el código Clojure/Lisp? ¿Estoy 'haciendo' rito '?

NOTA: No puedo prometer que el código que publiqué funciona. He estado haciendo algunos experimentos, y algunas cosas pueden ser muy sucky, si no roto.

Answer 1

La forma en que rompió las líneas es bastante normal. Aunque haría algunos pequeños cambios.

• Ponga los vectores de argumento en la siguiente línea.
• Use formas diferentes: los pequeños -> y ->> ayudantes, condp, cuando, ...
• Si es necesario, romper la línea inmediatamente después del nombre de la función.

Aquí cómo me gustaría ir sobre esto. (Negación:..! Mi estilo tuyo puede ser diferente 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))))) 

Aunque lo siguiente no es parte de su pregunta, no me puedo resistir:

(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

cuando las cosas intentan escapar del lado derecho Tiendo a su entrada después del primer argumento para cada llamada. esto solo sangra por un monto fijo por línea.

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

Answer 3

clojure modo para Emacs no lo hace necesariamente tener todas las sangrías correctas. Digo intentar mantener sus líneas por debajo de los 80 caracteres y ser consistente.