Bedingte "Zuweisung" in der funktionalen Programmierung

Question

Ich programmiere etwas, das keine Nebenwirkungen hat, aber mein Code ist nicht gut lesbar. Betrachten Sie das folgende Stück Code:

(let [csv_data (if header_row (cons header_row data_rows) data_rows)] 
) 

Ich versuche csv_data in einem Block von Code zu verwenden. Was ist eine saubere Art der Konditionierung auf das Vorhandensein eines header_row? Ich habe mir if-let angesehen, konnte aber nicht sehen, wie das hier helfen könnte.

Ich bin in ähnliche Situationen mit funktionalen for-Schleifen geraten, wo ich das Ergebnis an eine lokale Variable binde, und der Code sieht aus wie ein Stapel von Ausdrücken.

Muss ich wirklich in vielen Fällen eine separate Hilfsfunktion erstellen? Was fehlt mir hier?

Answer 1

Verwenden Sie zunächst keinen Unterstrich, sondern Bindestriche.

Zweitens ist nichts falsch mit einer kleinen Hilfsfunktion; Schließlich scheint dies eine Voraussetzung für die Handhabung Ihres speziellen Datenformats zu sein.

Drittens, wenn Sie Ihre Daten ändern können, so dass Sie diese Entscheidungen überspringen können und eine einheitliche Darstellung für alle Ecken Fälle haben, ist dies noch besser. Eine Kopfzeile enthält eine andere Art von Daten, so dass Sie könnte sie getrennt vorziehen zu halten (Spaltennamen?):

(let [csv {:header header :rows rows}] 
    ...) 

Oder vielleicht irgendwann könnten Sie „Header“ und „Reihen“ von der gleichen haben Typ: Reihenfolgen. Dann können Sie sie direkt concattieren. Das ensure-x Idiom ist eine sehr verbreitete Möglichkeit, Ihre Daten zu normalisieren:

(defn ensure-list [data] 
    (and data (list data))) 

Zum Beispiel:

user=> (ensure-list "something") 
("something") 
user=> (ensure-list()) 
(()) 
user=> (ensure-list nil) 
nil 

Und so:

(let [csv (concat (ensure-list header) rows)] 
    ...) 

Answer 2

Nach über die "Kosten" ein Denken Einzeilige Hilfsfunktion im Namensraum Ich habe stattdessen eine lokale Funktion entwickelt:

(let [merge_header_fn (fn [header_row data_rows] 
          (if header_row 
          (cons header_row data_rows) 
          data_rows)) 
     csv_data (merge_header_fn header_row data_rows) ] 
    ... 
    <use csv_data> 
    ... 
) 

Wenn nicht jemand einen eleganteren Umgang damit vorschlagen kann, werde ich dies als Antwort behalten.

Answer 3

Ich würde ein Dienstprogramm Makro vorschlagen. So etwas wie das:

(defmacro update-when [check val-to-update f & params] 
    `(if-let [x# ~check] 
    (~f x# ~val-to-update ~@params) 
    ~val-to-update)) 

user> (let [header-row :header 
      data-rows [:data1 :data2]] 
     (let [csv-data (update-when header-row data-rows cons)] 
      csv-data)) 
;;=> (:header :data1 :data2) 

user> (let [header-row nil 
      data-rows [:data1 :data2]] 
     (let [csv-data (update-when header-row data-rows cons)] 
      csv-data)) 
;;=> [:data1 :data2] 

es ist ziemlich universell, und Sie können komplexere Aufgaben erfüllen, dann einfach nur Consing. Wie zum Beispiel möchten Sie einige coll umkehren, wenn die Prüfung wahr ist, und eine andere Liste erstellen ...

user> (let [header-row :header 
      data-rows [:data1 :data2]] 
     (let [csv-data (update-when header-row data-rows 
            (fn [h d & params] (apply concat (reverse d) params)) 
            [1 2 3] ['a 'b 'c])] 
      csv-data)) 

;;=> (:data2 :data1 1 2 3 a b c) 

Update wie @amalloy bemerkt haben, dieses Makro eine Funktion sein sollte:

(defn update-when [check val-to-update f & params] 
    (if check 
    (apply f check val-to-update params) 
    val-to-update)) 

Answer 4

Verwenden Sie den cond->> Makro

(let [csv_data (cond->> data_rows 
       header_row (cons header-row)] 
    ) 

Es funktioniert wie die regelmäßige ->> Makro, aber vor jedem threading-Formular muss ein Testausdruck platziert werden, der bestimmt, ob der threadin g Formular wird verwendet.

Es gibt auch cond->. Lesen Sie mehr über Threading Makros hier: Official threading macros guide