Блог

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

Я ожидаю получить код, подобный приведенному ниже.

 trait Column {
  def rule
}

case object FirstColumn extends Column{
 def rule(s: String) : String
}

case object SecondColumn extends Column{
 def rule(s1: String, s2: String) : String
}
  

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

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

Вы можете выразить (что-то близкое к) желаемый тип, но я не уверен, что вы намерены получить. Во-первых, если вы хотите использовать разные типы списков аргументов, то Column он должен быть универсальным.

 trait Column[-A] {
  def rule(arg: A): String
}
  

Затем мы можем реализовать ваши объекты case как подклассы соответствующей параметризации этого.

 case object FirstColumn extends Column[String] {
  def rule(arg: String): String =
    "stub implementation"
}

case object SecondColumn extends Column[(String, String)] {
  def rule(arg: (String, String)): String =
    "stub implementation"
}
  

Обратите внимание, что FirstColumn и SecondColumn не наследуются от одного и того же Column[A] , поскольку они не реализуют один и тот же метод. Мы можем заставить их иметь общий тип, но… не очень полезным способом.

Один из вариантов — найти общий супертип Column[String] and Column[(String, String)] , который (поскольку аргумент контравариантен) сродни поиску общего подтипа String and (String, String) . Ближайший распространенный подтип — это … Null . Это бесполезно, если вы только не планируете передавать null в свой rule .

Вместо этого мы можем использовать existentials.

 val foo: Column[_] = FirstColumn
val bar: Column[_] = SecondColumn
  

Теперь мы потеряли всю информацию о типе. Вы можете получить доступ к слоту foo.rule и распечатать его, но вы не можете вызвать его, потому что мы не знаем, что нам нужно передать. Вам нужно будет выполнить приведение, чтобы вернуть ее к удобному формату.

Смысл, который я здесь подчеркиваю, заключается в том, что да, это выполнимо, но как только вы потеряете столько информации о типе, сколько отдаете, в этом не будет особого смысла. Система типов правильно сообщает нам, что foo и bar практически не имеют ничего общего, кроме существования метода с именем rule , который принимает … какой-то аргумент. С точки зрения теории типов, трудно придумать что-то более неинтересное, чем это.