Существует ли в каком-либо языке троичного оператора равенства равенство, которое проверяет равенство и возвращает либо сторону проверки, либо значение по умолчанию

Question

Время от времени мне нужно проводить некоторую оценку, подобную этой:

someVar == "something" ? "something" : "someOther"

обратите внимание, что == выполняет проверку на равенство, а не задание

Теперь мне интересно, есть ли какая-либо концепция на каком-либо языке, которая делает это выражение более компактным, например

someVar ?== "something" : "someOther"

Знаете ли вы язык, который предлагает такую ​​функцию, и если да, как эта концепция называется?

edit:
Поскольку в некоторых ответах уже предлагался троичный оператор или оператор elvis, это не то, что я ищу. Я ищу концепцию, которая по существу выполняет проверку на равенство в качестве условия троичного оператора и возвращает либо одну из сторон этой проверки, либо значение по умолчанию.

edit2:
I ' Я хотел бы еще раз подчеркнуть, что меня не интересуют решения, как вы можете достичь чего-то подобного, внедрив это самостоятельно. Это, конечно, не сложно сделать, но мне интересно, существует ли такая операция на каком-либо языке и есть ли для нее термин.

И также обратите внимание, что я не хочу обсуждать, действительно ли это или нет эта операция имеет смысл или должна быть частью языка.

Answer 1

Это возможно в Scala, поскольку позволяет перегрузить любого оператора. Единственная проблема заключается в том, что точка с запятой зарезервирована в Scala.

val someVar  = new Questioner("something")
println("Start " + someVar)

someVar ?== "something" `:` "someOther"

println(someVar) // something

someVar ?== "someOther" `:` "something"

println(someVar) // someOther

И это фактический код:

case class Questioner[T](private var value: Semicoloner[T]) {

  def `?==`(other: Semicoloner[T]) {
    if (this.value.value != other.other) {
      this.value = new Semicoloner(other.other)
    }
  }

  override def toString = this.value.value.toString
}

case class Semicoloner[T](val value: T, val other : T) {
  def `:`(other: Semicoloner[T]): Semicoloner[T] = {
    return new Semicoloner(this.value, other.value)
  }

  def this(value : T) {
    this(value, value) 
  }
}


implicit def anythingToSemicoloner[T](a : T) : Semicoloner[T] = {
  new Semicoloner(a)
}

Вероятно, может go с чем-то еще более безумным, но я ' остановлюсь здесь.

Answer 2

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

someVar = "someOther" unless someVar == "something"

... Так что нет, не как один оператор.

Answer 3

Я не думаю, что этот конкретный случай достаточно распространен для любого языка, чтобы иметь для него выделенный оператор. В вашем примере в комментарии к исходному вопросу (цитируемому ниже), это произвольное решение или случайное решение о том, что одна из возможных appType s совпадает с одной из двух возможных задач и соответствует исключительно с ним.

У меня только что было это в моем конвейере сборки: build(platform, (appType == "appstore" ? "appstore" : "build")). Функция build принимает два аргумента: платформу и задачу. Теперь, в соответствии с соглашением, в этом случае задача имеет то же имя, что и тип приложения, так что это сокращение было бы удобно использовать здесь.

Конечно, если ваш конкретный проект часто использует это, можно написать простую функцию, чтобы упростить его, а некоторые языки позволяют перегрузить операторы, чтобы вы могли использовать использование, подобное вашему псевдокоду.

Answer 4

В python более многословно, синтаксис такой:

a if condition else b

Пример:

def get_bigger(a, b):
    return a if a > b else b