linguaggio per le sequenze di imbottitura

Question

Per pad fuori una sequenza con un certo valore, questo è quello che è venuta in mente:

(defn pad [n coll val] 
    (take n (concat coll (repeat val)))) 

(pad 10 [1 2 3] nil) ; (1 2 3 nil nil nil nil nil nil nil) 

Sono curioso di sapere se c'è un linguaggio più breve che fa questo già e forse in modo più efficiente .

Answer 1

Sì, questo è un modo idiomatico di andare sulle partizioni di riempimento di una sequenza. Infatti che il codice è molto simile al part of the partition function in clojure.core la differenza che partition non assume un singolo valore di riempimento e invece richiede una sequenza:

core.clj:

([n step pad coll] 
(lazy-seq 
    ... 
    (list (take n (concat p pad)))))))) 

È possibile ottenere gli stessi risultati passando una collezione imbottitura per partizione:

user> (defn pad [n coll val] 
     (take n (concat coll (repeat val)))) 
#'user/pad 
user> (pad 10 [1 2 3] nil) 
(1 2 3 nil nil nil nil nil nil nil) 

user> (first (partition 10 10 (repeat nil) [1 2 3])) 
(1 2 3 nil nil nil nil nil nil nil) 

Answer 2

Ecco una versione pigra della funzione padding:

(defn lazy-pad 
    "Returns a lazy sequence which pads sequence with pad-value." 
    [sequence pad-value] 
    (if (empty? sequence) 
    (repeat pad-value) 
    (lazy-seq (cons (first sequence) (lazy-pad (rest sequence) pad-value))))) 

È possibile utilizzarlo come un normale raccolta pigro infinita:

(take 5 (lazy-pad [1 2 3] :pad)) 
=> (1 2 3 :pad :pad) 

IMO è più elegante in questo modo. È anche possibile utilizzarlo con altre funzioni che si aspettano una sequenza pigro, che non funziona se si deve specificare la lunghezza in anticipo:

(partition 2 (interleave [1 2 3 4] (lazy-pad [:a] :pad))) 
=> ((1 :a) (2 :pad) (3 :pad) (4 :pad))