В Clojure, если у меня есть функция f,
(defn f [& r] ... )
и у меня есть seq args с аргументами, которые я хочу вызвать f, я могу легко использовать apply:
(apply f args)
Теперь, скажем, у меня есть еще одна функция g, которая предназначена для принятия любого из нескольких необязательных именованных аргументов - то есть, где аргумент rest разрушен как карта:
(defn g [& {:keys [a b] :as m}] ... )
Обычно я называю g, делая что-то вроде
(g :a 1 :b 2)
но если у меня есть карта my-map со значением {: a 1: b 2}, и я хочу "применить" g к моей карте - другими словами, получить что-то, что закончилось бы как вышеупомянутый вызов, тогда я, естественно, не смог бы использовать apply, так как он был бы эквивалентен
(g [:a 1] [:b 2])
Есть ли хороший способ справиться с этим? Могу ли я уйти с пути в мой дизайн, чтобы закончить с этим? Лучшее решение, которое я могу найти, будет
(apply g (flatten (seq my-map)))
но мне это точно не нравится. Любые лучшие решения?
EDIT: Небольшое улучшение предлагаемого решения может быть
(apply g (mapcat seq my-map))
который, по крайней мере, удаляет один вызов функции, но может все еще не совсем ясно, что происходит.
Я сам наткнулся на эту проблему и в конечном итоге определил функции, чтобы ожидать одну карту. Карта может иметь переменное количество пар ключ/значение и, если она достаточно гибкая, поэтому нет необходимости и аргументов для останова. Также нет боли при применении. Делает жизнь намного проще!
(defn g [{:keys [a b] :as m}] ... )
Нет лучшего прямого способа, чем преобразование в seq.
Вы закончили. Вы сделали все, что могли.
На самом деле это не так уж сложно, если у вас есть общие функции Lisp style: keyword arg. Если вы посмотрите вокруг кода Clojure, вы обнаружите, что почти ничего не написано.
Даже большая RMS не является их поклонником:
"Одна вещь, которую мне не очень нравится, - это аргументы ключевого слова (8). Они мне не очень нравятся, я иногда это делаю, но я минимизирую время, когда я это делаю". (Источник)
В тот момент, когда вам нужно разбить полную хэш-карту на части, чтобы передать все из них в качестве сопоставленных ключевых слов, вы должны задать вопрос о своей функции.
Я нахожу, что в случае, когда вы хотите передать общие параметры, такие как :consider-nil true, вы, вероятно, никогда не будете вызывать функцию с хэш-картой {:consider-nil true}.
В случае, если вы хотите сделать оценку на основе некоторых ключей хэш-карты, вы в 99% случаев имеете объявление f ([m & args]).
Когда я начал определять функции в Clojure, я попал в ту же проблему. Однако, подумав больше о проблемах, которые я пытался решить, я заметил, что я почти никогда не использовал деструктурирование в объявлении функции.
Вот очень упрощенная функция, которая может использоваться точно так же, как применимо, за исключением того, что конечный arg (который должен быть картой) будет расширен до: key1 val1: key2 val2 и т.д.
(defn mapply
[f & args]
(apply f (reduce concat (butlast args) (last args))))
Я уверен, что есть более эффективные способы сделать это, и не хотите ли вы оказаться в ситуации, когда вам придется использовать такую функцию, для обсуждения, но она отвечает на оригинал вопрос. В основном, я по-детски доволен именем...
Самое лучшее решение, которое я нашел:
(apply g (apply concat my-map))