Простое управление потоком и привязка переменных в Clojure

Question

Я изучаю Clojure и работаю над простым скриптом синтаксического анализа файлов.

У меня есть файл в виде:

pattern1
pattern2
pattern3
pattern1
pattern2
...

, где в каждой строке есть несколько значений (чисел), которые я извлекаю.

Если бы я написал это, например, в Java, я бы сделал что-то похожее на:

Map<String, Integer> parse(String line) {
    //using Optional in this toy example, but could be an empty map or something else to
    //signal if first one was actually matched and the values are there
    Optional<Map<String, Integer>> firstMatched = matchFirst(line);
    if (firstMatched.isPresent()) {
        return firstMatched.get();
    }
    //...do the same for 2 remaining patterns
    //...
}

Теперь Что бы было элегантным или идиоматическим c сделать что-то подобное в Clojure ?

Полагаю, я могу использовать cond , но поскольку в тестовом выражении нет привязки, мне придется дважды проанализировать строку:

(defn parse
  [line]
  (cond
    (re-find #"pattern-1-regex" line) (re-find...)
    (re-find #"pattern-2-regex" line) (re-find...

Я мог бы также используйте if-let , но это будет много вложений, так как есть 3 различных варианта. Представьте, как это будет выглядеть с помощью 7 различных шаблонов.

Есть предложения? Очевидно, что решение Java является обязательным, и я могу сделать «возврат», когда захочу, так что бы это был Clojure / FP способ работы с этим простым ветвлением.

Answer 1

Учитывая некоторые примеры данных:

(ns tst.demo.core
  (:use demo.core tupelo.core tupelo.test)
  (:require
    [clojure.string :as str]
    [tupelo.string :as ts]
    [tupelo.parse :as parse]))

(def data-str "
  fred123 1 2 3
  fred456   4 5    6
  wilma12  1.2
  wilma34 3.4
  barney1 1
  barney2 2
  ")

Затем вы можете определить функции разбора для каждого типа данных:

(defn fred-parser
  [line]
  (let [tokens        (str/split line #"\p{Blank}+")
        root          (first tokens)
        details       (rest tokens)
        parsed-root   (re-find #"fred\n*" root)
        parsed-params (mapv parse/parse-long details)
        result        {:root parsed-root :params parsed-params}]
    result))

(defn wilma-parser
  [line]
  (let [tokens        (str/split line #"\p{Blank}+")
        root          (first tokens)
        details       (rest tokens)
        parsed-root   (re-find #"wilma\n*" root)
        parsed-params (mapv parse/parse-double details)
        result        {:root parsed-root :params parsed-params}]
    result))

Я бы сделал карту из шаблона в функцию разбора:

(def pattern->parser
  {#"fred\d*"  fred-parser
   #"wilma\d*" wilma-parser
   })

и некоторые функции для поиска правильного парсера для каждой строки (очищенных) данных:

(defn parse-line
  [line]
  (let [patterns          (keys pattern->parser)
        patterns-matching (filterv ; keep pattern if matches
                            (fn [pat]
                              (ts/contains-match? line pat))
                            patterns)
        num-matches       (count patterns-matching)]
    (cond
      (< 1 num-matches) (throw (ex-info "Too many matching patterns!" {:line line :num-matches num-matches}))
      (zero? num-matches) (prn :no-match-found line)
      :else (let [parser      (get pattern->parser (only patterns-matching))
                  parsed-line (parser line)]
              parsed-line))))

(defn parse-file
  [data]
  (let
    [lines       (filterv #(not (str/blank? %)) ; remove blank lines
                   (mapv str/trim ; remove leading/trailing whitespace
                     (str/split-lines data))) ; split into lines
     parsed-data (mapv parse-line lines)]
    parsed-data))

и модульный тест, чтобы показать его в действии:

(dotest
  (is= (parse-file data-str)
    [{:root "fred", :params [1 2 3]}
     {:root "fred", :params [4 5 6]}
     {:root "wilma", :params [1.2]}
     {:root "wilma", :params [3.4]}
     nil
     nil])
  )

Обратите внимание, что несопоставленные строки возвращают ноль. Вы захотите либо сгенерировать исключение для проблем, либо хотя бы отфильтровать значения nil. Прямо сейчас вы получите сообщение об ошибке:

-------------------------------
   Clojure 1.10.1    Java 14
-------------------------------

Testing tst.demo.core
:no-match-found "barney1 1"
:no-match-found "barney2 2"

Ran 2 tests containing 1 assertions.
0 failures, 0 errors.

Дополнительная документация здесь и здесь .

Answer 2

Я бы go с некоторой простой функцией, чтобы вернуть первый сопоставленный шаблон, фильтруя по шаблонам seq:

(defn first-match [patterns]
  (fn [line]
    (some #(re-find % line) patterns)))

, эта функция возвращает функцию, которая будет возвращать первое совпадение, проверяя строку :

user> (def mat (first-match [#"(asd)" #"(fgh)" #"aaa(.+?)aaa"]))
#'user/mat

user> (mat "aaaxxxaaa")
;;=> ["aaaxxxaaa" "xxx"]

user> (mat "nomatch")
;;=> nil

в противном случае вы можете использовать для этого какой-нибудь простой макрос. может быть так:

(defmacro when-cond [& conds]
  (when (seq conds)
    `(if-let [x# ~(first conds)]
       x#
       (when-cond ~@(rest conds)))))

user> 
(let [line "somethingaaa"]
  (when-cond
    (re-find #"something" line)
    (re-find #"abc(.*?)def" line)))
;;=> "something"

для предыдущего примера, который расширится до чего-то подобного (схематично)

(if-let [x__8043__auto__ (re-find #"something" line)]
  x__8043__auto__
  (if-let [x__8044__auto__ (re-find #"abc(.*?)def" line)]
    x__8044__auto__
    nil))

больше примеров:

user> 
(let [line "nomatch"]
  (when-cond
    (re-find #"something" line)
    (re-find #"abc(.*?)def" line)))
;;=> nil

user> 
(let [line "abcxxxxxxdef"]
  (when-cond
    (re-find #"something" line)
    (re-find #"abc(.*?)def" line)))
;;=> ["abcxxxxxxdef" "xxxxxx"]