Как мне преобразовать List[Option[(A, List[B])]] в Option[(A,List[B])]? (В основном получить Option[X] из списка[Option[X]])
У меня есть список кортежей “rules” следующим образом:
val rules = List[(A, List[B])], где A и B — два отдельных case-класса
Для целей моего варианта использования мне нужно преобразовать это в Option[(A, List[B])]. Класс case A содержит свойство id типа Option[String], на основе которого возвращается кортеж.
Я написал функцию def findRule(entryId: Option[String]), из которой намерен вернуть кортеж (A, List[B]), чей A.id = entryId в качестве опции. На данный момент я написал следующий фрагмент кода:
def findRule(entryId: Option[String]) = {
for {
ruleId <- rules.flatMap(_._1.id) // ruleId is a String
id <- entryId // entryId is an Option[String]
} yield {
rules.find(_ => ruleId.equalsIgnoreCase(id)) // returns List[Option[(A, List[B])]
}
}
Этот фрагмент возвращает List[Option[(A, List[B])], но я не могу понять, как получить из него только Option. Использование .head() не вариант, так как список rules может быть пуст. Пожалуйста, помогите, так как я новичок в Scala.
Пример (реальные примеры слишком велики, чтобы публиковать их здесь, поэтому, пожалуйста, рассмотрите этот репрезентативный пример):
val rules = [(A = {id=1, ….}, B = [{B1}, {B2}, {B3}, …]), (A = {id=2, ….}, B = [{B10}, {B11}, {B12}, …]), …. ] (B здесь не особо важно, мне нужно найти кортеж на основе id элемента case-class A)
Теперь предположим entryId = Some(1)
После функции findRule() это будет выглядеть так:
[Some((A = {id=1, …}, B = [{B1}, {B2}, {B3}, …]))]
Я хочу вернуться:
Some((A = {id=1, …}, B = [{B1}, {B2}, {B3}, …])) , т. е. опция в списке, возвращенная (в настоящее время) из findRule()
Также не могли бы вы включить пример с фактическим списком и как он будет выглядеть после преобразования? Пожалуйста, сделайте список небольшим, например, три элемента.
Привет, да, rules val это List[(A, List[B])]. Затем я конвертирую rules в List[Option[(A, List[B])] в функции findRule() (намереваясь преобразовать его только в Option, но я не могу этого понять). Я хочу преобразовать результат этой функции findRule() в Option[(A, List[B])].
У вас есть список, который вы хотите преобразовать в один элемент. Это означает, что вам нужно выбрать элемент или уменьшить список в соответствии с некоторой логикой. Предполагая, что вы хотите выбрать элемент; какой элемент вы хотите выбрать? Если вам просто нужен первый элемент, вы, вероятно, можете использовать headOption.flatten.
Кажется, это просто collectFirst? За этим вопросом трудно уследить, так как он добавляет слишком много ненужных деталей.
Ответы 2
Судя по вашему вопросу, вы пытаетесь выбрать один элемент из своего списка на основе некоторого условного выражения, что означает, что вы, вероятно, захотите начать с rules.find. Затем возникает проблема, как выразить функцию предиката, которую вы передаете find.
Из моего прочтения вашего вопроса условное выражение
idвAчасти кортежа должен совпадать сentryId, который был передан в другом месте
def findRule(entryId: Option[String]) =
rules.find { case (a, listOfB) => entryId.contains(a.id) }
Выражение case — это просто хороший синтаксис для работы с кортежем. я бы тоже мог сделать
rules.find { tup => entryId.contains(tup._1.id) }
Метод contains в Option примерно делает «если я Some, посмотрите, равно ли мое значение аргументу; если я None, просто верните false и игнорируйте аргумент». Это работает как сравнение между Option[String], которое у вас есть для entryId, и простым String, которое у вас есть для A's id.
Ваша первая попытка не сработала, потому что rules.flatMap дал вам List, и использование этого после <- в for-comprehension означает еще один flatMap, который хранит вещи в виде списка.
Вариант, который я лично предпочитаю, это
def findRule(entryId: Option[String]): Option[(A, List[B])] = {
entryId.flatMap { id =>
rules.find { case (a, _) => a.id == id }
}
}
В случае, когда entryId равно None, он сразу же возвращает None. Если вы начнете с rules.find, то он будет перебирать все правила и проверять каждое, даже если entryId равно None. Маловероятно, что какая-либо заметная разница в производительности будет иметь место, если список правил небольшой, но я также нахожу его более интуитивно понятным.
Привет. В заголовке вы говорите «Как мне преобразовать
List[Option[(A, List[B])]]...", но в теле вы говоритеval rules = List[(A, List[B])]. Который из них?