Как сгруппировать данные, прикрепленные к размеченным значениям объединения, в F#?
Вот пример:
type Events =
| A of AData
| B of BData
| C of CData
и у меня есть список из них:
let events : Events list = ...
Мне нужно построить список по типу события. Прямо сейчас я делаю это:
let listA =
events
|> List.map (fun x ->
match x with
| A a -> Some a
| _ -> None
)
|> List.choose id
и, повторите для каждого типа...
Я также думал, что могу сделать что-то вроде:
let rec split events a b c =
match events with
| [] -> (a |> List.rev, b |> List.rev, c |> List.rev)
| h :: t ->
let a, b, c =
match h with
| A x -> x::a, b, c
| B x -> a, x::b, c
| C x -> a, b, x::c
split t a b c
Есть ли более элегантный способ решить эту проблему?
Это обрабатывает много данных, поэтому здесь важна скорость.
type Events может быть неоптимальным для поставленной задачи. Конечно, зависит от масштаба рефакторинга, который может быть предоставлен.
Я уже сталкивался с этой проблемой. Это один из немногих (относительно редких) случаев, отмеченных мной в F#, когда вы знаете, что хотите сделать, но язык не предлагает элегантного способа сделать это. Так что полезных советов у меня нет. Ваш вариант B - это то, что я обычно делал (это не слишком неэлегантно;))
Ответы 3
Я думаю, что ваше решение довольно хорошее, хотя вы платите цену за изменение списков. Единственный другой полуэлегантный подход, который я могу придумать, - распаковать список кортежей:
let split events =
let a, b, c =
events
|> List.map (function
| A n -> Some n, None, None
| B s -> None, Some s, None
| C b -> None, None, Some b)
|> List.unzip3
let choose list = List.choose id list
choose a, choose b, choose c
Это создает несколько промежуточных списков, поэтому осторожное внутреннее использование Seq или Array вместо этого может работать лучше. Вы должны были бы сравнить, чтобы быть уверенным.
Прецедент:
split [
A 1
A 2
B "one"
B "two"
C true
C false
] |> printfn "%A" // [1; 2],[one; two],[true; false]
Кстати, ваше текущее решение можно упростить до:
let listA =
events
|> List.choose (function A a -> Some a | _ -> None)
Вы можете свернуть список событий, чтобы избежать написания рекурсивной функции и обращения результатов. С анонимной записью вам нужно сначала определить ее, а затем передать оба аргумента ||> в List.foldBack:
let eventsByType =
(events, {| listA = []; listB = []; listC = [] |})
||> List.foldBack (fun event state ->
match event with
| A a -> {| state with listA = a :: state.listA |}
| B b -> {| state with listB = b :: state.listB |}
| C c -> {| state with listC = c :: state.listC |})
С именованной записью это более элегантно:
{ listA = []; listB = []; listC = [] } |> List.foldBack addEvent events
addEvent такая же, как лямбда выше, за исключением использования именованной записи {} вместо {||}.
Ага, фолд и друзья реализованы императивно, поэтому в свое время должны были быть более эффективными. С другой стороны, обращение списков очень идиоматично. Я не удивлюсь, если компилятор F# оптимизирует это, учитывая, сколько времени компиляция занимает мой ЦП Gen12… Без (а) требований к производительности и (б, если а) бенчмаркинга, предпочтение — это просто личное предпочтение. Я ни в коем случае не спорю, просто делюсь своими мыслями. Отсутствуют данные по (а) и (а) -> (б), я разрываюсь между ОП и вашими решениями, поэтому я проголосую за оба :-)) О, кстати, «Думая ...» Дэни Канеман это книга!!!
О, и анонимные записи значений не должны мешать производительности. Но... (б->а). Бенчмарк, бенчмарк, бенчмарк — если у вас есть причины сделать код более производительным.
Если вы сохраните случаи объединения, вы можете сгруппировать элементы списка следующим образом.
let name = function
| A _ -> "A"
| B _ -> "B"
| C _ -> "C"
let lists =
events
|> List.groupBy name
|> dict
И тогда вы можете извлечь данные, которые вы хотите.
let listA = lists["A"] |> List.map (fun (A data) -> data)
(Компилятор не понимает, что список состоит только из случаев «А», поэтому выдает предупреждение о неполном совпадении с образцом😀)
Возможно, List.group