Что такое Scala "мощный" тип системы?

Ответ 1

Я не думаю, что существующие ответы подходят. Scala имеет множество удобств, но они не связаны с тем, что система типов является мощной только потому, что они относятся к типам. Фактически, вывод типа находится в прямом противоречии с мощью системы типов - был ли он менее мощным, можно было бы иметь полный вывод типа (например, в Haskell).

Итак,

• Scala имеет классы с членами. (Очевидно, но я стараюсь быть исчерпывающим здесь.)
• Элементы класса () класса Scala могут иметь ноль или более списков параметров, каждый из которых может иметь ноль или более параметров, последним из которых может быть vararg.
• Параметры могут передаваться по значению или по имени.
• Параметры имеют имена и могут иметь значения по умолчанию.
• Scala имеет члены "var" и "val" (которые на практике также являются методами).
• Scala имеет члены "lazy val".
• Scala имеет "тип" членов (псевдонимы типов), которые могут быть указаны как фиксированные типы или как границы типов.
• Scala имеет абстрактные классы и члены (все вышеперечисленные члены могут быть абстрактными).
• Scala имеет внутренний класс, свойства и объекты (внутренний класс Scala отличается от Java).
• Scala, а также внутренние вещи, могут быть переопределены.
• Scala имеет наследование типов.
• Scala имеет черты, обеспечивающие множественное наследование линеаризацией типов.
• Scala Элементы метода признаков могут иметь абстрактное переопределение (стекируемое, аспектное переопределение).
• Scala имеет одноэлементные типы.
• Scala имеет сопутствующий класс/объекты (связанные с областью действия).
• Scala имеет частные, защищенные и общедоступные области для классов, черт, одиночек и членов.
• Scala частные и защищенные области могут быть ограничены любым охватывающим пакетом, классом, признаком или синглетом, а также "this".
• Scala имеет собственные типы.
• Scala имеет параметры типа.
• Scala параметры типа могут быть со-и противоречивыми, а также инвариантными.
• Scala имеет конструкторы типов.
• Scala имеет типы более высокого порядка.
• Scala имеет экзистенциальные типы.
• Scala имеет структурные типы.
• Scala имеет неявные параметры.
• Scala имеет типы функций, хотя, поскольку они просто класс плюс синтаксический сахар, я не думаю, что он принадлежит этому списку. С другой стороны, типы функций являются частью границ представления, поэтому, возможно, это так.
• Scala имеет верхнюю (как почти все) и нижнюю (как и другие статически типизированные языки fp).
• Scala "unit" - это тип со значением (в отличие от "void" в другом месте).

Далее, есть функции, связанные с Scala implicits, что и заслуживает их включения выше.

• Scala имеет границы представлений, неявный параметр, который действует как привязка другого типа.
• Scala имеет контекстные ячейки, неявный параметр, который действует как другая граница.
• Вообще говоря, неявные параметры и вывод типа могут быть объединены для построения произвольных комплексных доказательств по параметрам типа.

Связанный с последним комментарием, подразумевает и выводит тип вместе, завершает завершение системы Scala. То есть вы кодируете произвольные программы как типы, которые будут выполняться компилятором во время компиляции. Доказательство здесь, посредством вычисления SKI, с "багги" бесконечным циклом в типах в качестве дополнительной демонстрации.

Перечень функций, приведенных выше, довольно большой и впечатляющий во многих аспектах. Тем не менее, метод Scala объединяет implicits и вывод типа для создания статических доказательств во время компиляции (таких как границы представлений и границы контекста), которые делают систему типа Scala уникальной. AFAIK, нет другого языка, который делает это, хотя есть, конечно, и другие языки, предоставляющие возможности доказательства с помощью других средств.

Ответ 2

Несколько преимуществ системы типа Scala над Java:

• Типы можно вывести во многих случаях, а не указывать явно. Это более удобно, но оно способствует использованию сложных типов.

  val map = new Map[String, (String, String)]()

  вместо

  Map<String, Tuple<String, String>> map = new HashMap<String, Tuple<String, String>>()

• Функции могут быть выражены просто в системе типов. Если вы хотите увидеть, насколько это мощно, рассмотрите библиотеку guava как обход для Java. Это невероятно сдержанно и многословно (но все же полезно).

  val double = (x: Int) => x * 2

  вместо (используя Guava)

  Function<Integer, Integer> double = new Function<Integer, Integer>() { @Override public Integer apply(Integer value) { return value * 2; }}

• Кортежи - это тип в Scala, обходя Java-проблему только для возможности вернуть одно значение.

• Scala поддерживает тип Variances, поэтому вы можете указать, что SomeObject является подтипом SomeObject, когда Cat является подтипом Thing ( или когда имеет место обратное соотношение). В java дженерики не являются ковариантными, что часто бывает проблематичным.

• Scala поддерживает ограниченную форму множественного наследования с помощью признаков. В отличие от интерфейсов (из которых несколько могут быть реализованы в Java), черты могут определять методы и переменные.

• Массивы прозрачно обрабатываются, как и любой другой класс.

• Вы можете добавлять методы к существующим классам через неявные определения. Например, вы можете добавить метод "sum" к массивам целых чисел.

  class IntArray(value: Array[Int]) { def sumIt = value.reduceRight(_+_) }
  implicit def pimpArray(xs: Array[Int]) = new IntArray(xs)
  Array(1,2,3).sumIt
  

Это еще один хороший ресурс для некоторых из вышеперечисленных тем: http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-5

Ответ 3

В дополнение к превосходному ответу schmmd система типа Scala имеет еще более важные функции:

• object являются чистой альтернативой переменным и методам static в Java, например. a object имеет свой собственный тип и может быть передан как аргумент
• type: вы можете определить псевдонимы для сложных типов, например type FactorMap[A] = Map[A, Set[Int]]
• члены абстрактного типа в качестве альтернативы типам типового стиля
• типы self
• структурные типы
• несколько списков аргументов для currying
• неявные параметры и преобразования, а также границы представлений. Это приводит к шаблону "pimp my library" и может использоваться для имитации стилей стиля Haskell.
• типы более высокого порядка

Последний пункт - один из моих любимых. Например. вы не можете написать простой общий интерфейс functor в Java. Вам понадобится...

public interface Function<A,B> {
   public B apply(A a);
}

//not valid Java
public interface Functor<C> {
   public <A,B> C<B> map(Function<A,B> fn, C<A> ca);
}

Он работает, если вы замените какой-то конкретный тип типа List вместо C. В Java вы можете абстрагироваться над содержимым сдерживающего устройства (например, записывая "Список" ), но вы не можете абстрагироваться над самим контейнером. Поверьте мне, я попытался найти лазейки (результат был this). В Scala это ветер:

trait Functor[C[_]] {
   def map[A,B](fn: A => B, ca: C[A]):C[B]
}

object ListFunctor extends Functor[List] {
   def map[A,B](fn: A => B, ca: List[A]):List[B] = ca.map(fn)
}

Ответ 4

Любая система типов, в которой вы можете кодировать HList, TList и HOF для типов, является довольно мощным IMHO. Подробнее см. http://apocalisp.wordpress.com/2010/06/08/type-level-programming-in-scala/.

Ответ 5

Я не знаю, знаете ли вы Java, но представьте Scala такую ​​систему, как это:

• Удалить искусственные ограничения Java того, что вы можете делать с типами и дженериками
• Добавьте к нему общие функции функциональных языков
• Инновации на фронте oop/inheritance

Мне бы хотелось одеться больше, запустила клавиатуру jus, извините!