Войти
 | |
| Парадигма | Мультипарадигма : параллельный, функциональный, императивный, объектно-ориентированный |
|---|---|
| Разработан | Мартин Одерски |
| Разработчик | Лаборатория методов программирования Федеральная политехническая школа Лозанны |
| Впервые появилось | 20 января 2004 г.; 16 лет назад (20.01.2004) |
| Стабильный выпуск | 2.13.3 / 25 июня 2020 г.; 4 месяца назад (25.06.2020) |
| Дисциплина ввода | Предполагаемый, статический, сильный, структурный |
| Язык реализации | Scala |
| Платформа |
|
| Лицензия | Лицензия Apache 2.0 |
| Расширения имени файла | .scala,.sc |
| Веб-сайт | www.scala-lang.org |
| Под местной | |
| Common Lisp, Eiffel, Erlang, Haskell, Java, OCaml,Oz, Pizza, Схема, Smalltalk, Стандартный ML | |
| Под влиянием | |
| Цейлон, Fantom, F#, Котлин, Лассо, Red | |
| |
Scala () - это универсальное программирование языка, обеспечивающий ориентированную поддержку как объектно-ориентированного программирования, так и функционального программирования. Язык имеет сильную статическую систему типов. Разработан Короче говоря, многие дизайнерские решения Scala задействует адрес критика Java.
Исходный код Scala, предназначенный для компиляции в байт-код Java, чтобы полученный исполняемый код работал на машине Java. Scala обеспечивает взаимодействие языков с Java, поэтому на библиотеки, написанные на любом языке, можно ссылаться непосредственно в коде Scala или Java. Как и Java, Scala объектно-ориентирована и использует синтаксис фигурных скобок, напоминающий язык программирования C. В отличие от Java, Scala имеет множество функций языков функционального программирования, таких как Scheme, Standard ML и Haskell, включая каррирование <56.>, неизменяемость, ленивое вычисление и сопоставление с образцом. Он также имеет расширенную систему типов, поддерживающих алгебраические типы данных, ковариацию и контравариантность, типы более высокого порядка (но не типа более высокого ранга ) и анонимные типы. Другие функции Scala, отсутствующие в Java, включая перегрузку оператора, необязательные параметры, именованные параметры и необработанные строки. И наоборот, особенность Java, отсутствующая в Scala, - это проверенные исключения, что оказалось спорным.
Имя Scala - это набор масштабируемости и языка, означающий, что он предназначен для роста вместе с требованиями пользователей.
Разработка Scala началась в 2001 году в Федеральной политехнической школе Лозанны (EPFL) (в Лозанне, Швейцария ) Мартином Одерски.. Он стал продолжением работы над Funnel, языком программирования, сочетающим функции функционального программирования и сетей Петри. Одерский раньше работал над Generic Java и javac, компилятором Java Sun от Sun.
После внутреннего выпуска в конце 2003 года Scala публично опубликован в начале 2004 года на Платформа Java, вторая версия (v2.0) последовала в марте 2006 года.
17 января 2011 года команда Scala выиграла пятилетний исследовательский грант на сумму более 2,3 миллиона евро от Европейский исследовательский совет. 12 мая 2011 года Одерский и его сотрудники основали Typesafe Inc. (позже переименованную в Lightbend Inc. ), компанию, предоставляющую коммерческую поддержку, обучение и услуги для Scala. В 2011 году компания Typesafe получила 3 миллиона долларов инвестиций от Greylock Partners.
Scala работает на платформе Java (виртуальная машина Java ) и совместим с существующими программами Java. Приложения время Android обычно пишутся на Java и преобразуются из байт-кода Java в байт-код Dalvik (который может быть установлен в машинный код во время установки) в упаковке, совместимость Scala с Java делает это хорошо. -подходит для разработки под Android, в большей степени, когда предпочтителен функциональный подход.
Эталонный дистрибутив программного обеспечения Scala, включая компилятор и библиотеки, выпущенный под лицензией Apache.
Scala.js - это компилятор Scala, который компилируется в JavaScript, что позволяет писать программы Scala, которые можно запускать в веб-браузерах или Node.js. Компилятор находился в разработке с 2013 года, а в 2015 году он был объявлен не экспериментальным (v0.6). Версия v1.0.0-M1 была выпущена в июне 2018 года. В сентябре 2020 года это версия 1.1.1.
Scala Native - это компилятор Scala , ориентированный на LLVM <56.>инфраструктура компилятора для создания исполняемого кода который использует управляемую среду выполнения, которая использует сборщик мусора Боэм. Проект планеты Денис Шабалин, его первая версия, 0.1, вышла 14 марта 2017 года. Разработка Scala Native началась в 2015 году с целью быть быстрее, чем своевременная компиляция для JVM. исключая начальную компиляцию кода во время выполнения, а также возможность самостоятельного запуска собственных подпрограмм.
Эталонный компилятор Scala, ориентированный на .NET Framework и его Common Language Runtime был выпущен в июне 2004 г., но официально была прекращена в 2012 г.
Программа Hello World, написанная на Scala имеет следующую форму:
объект HelloWorld extends App {println («Hello, World!»)}В отличие от автономного приложения Hello World для Java, здесь нет объявления класса и ничего не объявлен статичным; Вместо этого используется одноэлементный объект , созданный с помощью ключевого слова объект .
Когда программа сохраняется в файле HelloWorld.scala, пользователь компилирует ее с помощью команды:
$ scalac HelloWorld.scala
и запускает с
$ scala HelloWorld
Это аналог процесса компиляции и выполнения кода Java. Действительно, модель компиляции и выполнения Scala идентична модели Java, что делает ее программу совместимой с инструментами сборки Java, такими как Apache Ant.
Укороченная версия Scala "Hello World":
println ("Hello, World!")Scala включает поддержку интерактивной оболочки и сценариев. Сохраненный в файле с именем HelloWorld2.scala, его можно запустить как сценарий без предварительной компиляции, используя:
$ scala HelloWorld2.scala
Также можно ввести команды непосредственно в интерпретатор Scala с помощью параметра -e:
$ scala -e 'println ("Hello, World!")'Выражения можно ввести интерактивно в REPL :
$ scala Добро пожаловать в Scala 2.12.2 (64-разрядная серверная виртуальная машина Java HotSpot (TM), Java 1.8.0_131). Укажите выражения для оценки. Или попробуйте: помогите. scala>List (1, 2, 3).map (x =>x * x) res0: List [Int] = List (1, 4, 9) scala>
Следующий пример показывает различия между синтаксисом Java и Scala:
// Java: int mathFunction (int num) {int numSquare = num * num; return (число) (Math.cbrt (numSquare) + Math.log (numSquare)); } | |
// Scala: прямое преобразование из Java // импорт не требуется; scala.math // уже импортирован как `math` def mathFunction (num: Int): Int = {var numSquare: Int = num * num return (math.cbrt (numSquare) + math.log (numSquare)). asInstanceOf [Int]} | // Scala: более идиоматический // Использует вывод типа, опускает оператор return, // использует метод toInt, объявляет неизменяемый импорт numSquare math._ def mathFunction (num: Int) = {val numSquare = num * число (cbrt (numSquare) + log (numSquare)). toInt} |
Некоторые синтаксические различия в этом коде:
Int, Double, Booleanвместо int, double, boolean.def.val(указывает на неизменяемую переменную) или var(указывает на изменяемую переменную).returnне нужен в функции (хотя и разрешен); значение последнего выполненного оператора или выражения обычно является выполненным функции.(Type) fooв Scala используется foo.asInstanceOf [Type]или специализированная функция, такая как toDoubleили toInt.import foo. *;в Scala используется import foo._.foo ()также можно просто вызвать как foo; метод thread.send (signo)также может вызываться как просто thread send signo; и метод foo.toString ()также может вызываться как просто foo toString.Эти синтаксические ослабления предназначены для поддержки языков, зависящих от предметной области.
Некоторые другие базовые синтаксические различия:
array (i), а не array [i]. (Внутри Scala первый расширяется до array.apply (i), который возвращает ссылку)List [String], а не Java List .voidв Scala есть фактический одноэлементный класс Unit(см. Ниже).В следующем примере сравнивается определение классов в Java и Scala.
// Java: открытый класс Point {частный конечный двойной x, y; общественная точка (последний двойной x, последний двойной y) {this.x = x; this.y = y; } общедоступная точка (конечный двойной x, последний двойной y, конечный логический addToGrid) {this (x, y); если (addToGrid) grid.add (это); } public Point () {это (0,0, 0,0); } public double getX () {return x; } public double getY () {return y; } double distanceToPoint (конечная точка other) {вернуть distanceBetweenPoints (x, y, other.x, other.y); } приватная статическая сетка Grid = new Grid (); статическое удвоение distanceBetweenPoints (последнее двойное x1, последнее двойное y1, последнее двойное x2, последнее двойное y2) {return Math.hypot (x1 - x2, y1 - y2); }} | // Scala класс Point (val x: Double, val y: Double, addToGrid: Boolean = false) {import Point._ if (addToGrid) grid.add (this) def this () = this (0.0, 0.0) def distanceToPoint (other: Point) = distanceBetweenPoints (x, y, other.x, other.y)} объект Point {private val grid = new Grid () def distanceBetweenPoints (x1: Double, y1: Double, x2: Double, y2: Double) = {math.hypot (x1 - x2, y1 - y2)}} |
В приведенном выше коде показаны некоторые концептуальные различия между обработкой классов Java и Scala:
объектавместо класса. Обычно статические переменные и методы помещаются в одноэлементный объект с тем же именем, что и имя класса, который называется сопутствующим объектом. (Базовый класс для одноэлементного объекта имеет добавленный $. Следовательно, для класс Fooс сопутствующим объектом объект Foo, под капотом есть класс Foo $, используется код сопутствующего объекта, и один объект создается с использованием шаблона singleton.)varполя также контролируются тем же и автоматически инициализируются из параметров класса. (Под капотом, внешний доступ к общедоступным полям всегда осуществляется через методы доступа (получатель) и мутатор (установщик), которые Автоматически функция доступа имеет то же имя, что и поле, поэтому в приведенном выше примере нет необходимости объявлять методы доступа.) етствовать по умолчанию Конструктор ult (кроме инициализации чисел-членов) работает непосредственно на уровне класса.общедоступные.Scala имеет ту же модель компиляции, что и Java и C #, а именно раздельная компиляция и загрузка динамического класса, так что код Scala может вызвать библиотеку Java.
Рабочие характеристики Scala такие же, как у Java. Компилятор Scala генерирует байт-код, почти идентичный тому, который генерирует компилятором Java. Фактически, код Scala можно декомпилировать в читаемый код Java, за исключением некоторых операций конструктора. Для виртуальной машины Java (JVM) код Scala и код Java неотличимы. Единственное отличие - одна дополнительная библиотека времени выполнения, scala-library.jar.
Scala отличается большое количество функций по сравнению с Java и некоторые фундаментальные отличия в своих типах моделей выражений и типов, которые делают язык теоретически очистить и исключить несколько угловых случаев в Яве. С точки зрения Scala практически важно, потому что несколько дополнительных функций Scala доступны также и в C #. Примеры:
Как включается выше, Scala обладает синтаксической гибкостью по сравнению с Java. Ниже приведены некоторые примеры:
"% d яблоки".format (num)и формат "% d apples" numэквивалентны. Фактически, арифметические операторы, такие как +и <<, обрабатываются так же, как и любые другие методы, поскольку функции могут состоять из последовательностей произвольных символов (с некоторыми исключениями, сделанными для таких вещей, как скобки, скобки и подтяжки, с которой нужно обращаться особо); единственная особая обработка, которой подвергаются такие методы с именами символов, указанием приоритета обработки.имеюти updateсинтаксические краткие формы. foo ()- где foo- значение (одноэлементный объект или экземпляр класса) - это сокращение от foo.apply ()и foo () = 42- это сокращение от foo.update (42). Аналогично, foo (42)- это сокращение от foo.apply (42), а foo (4) = 2- сокращение от foo. обновление (4, 2). Это используется для классов коллекций и распространяется на многие другие случаи, такие как STM cells.def foo = 42) и пустые -parens (def foo () = 42) методы. При вызове метода с пустыми скобками скобки можно опустить, что полезно при вызове библиотек Java, которые не знают этого различия, например, при использовании foo.toStringвместо foo.toString (). По соглашению должен быть определен с пустыми скобками, когда он выполняет побочные эффекты.:), ожидают аргумент слева и получателя с правой стороны. Например, 4 :: 2 :: Nilсовпадает с Nil.::(2).::(4), первая форма визуально соответствует результату (список с первым элементом 4 и вторым Элемент 2).трейта FooLike {var bar: Int}реализацией может быть объект Foo extends FooLike {private var x = 0; def bar = x; def bar _ = (значение: Int) {x = value}}}}. Сайт вызова по-прежнему может использовать краткий foo.bar = 42.ломкий {... if (...) break ()...}выглядит так, как если бы ломаемыйбыло ключевым словом определенным языком, но на самом деле это просто метод, принимающий аргумент thunk. Методы, которые принимают преобразователи или функции, часто используют их во второй список параметров, позволяя смешивать синтаксис круглых и фигурных скобок: Vector.fill (4) {math.random}то же самое, что Vector. fill (4) (math.random). Вариант с фигурными скобками позволяет выражению занимать несколько строк.map, flatMapи filter.Сами по себе варианты могут показаться сомнительными, но в совокупности они позволяют определять предметно-ориентированные языки в Scala без расширения компилятора. Например, специальный синтаксис Erlang для отправки сообщения субъекту, то есть субъекту! сообщениеможет быть (и реализуется) в библиотеке Scala без расширения языка.
Java делает четкое различие между примитивными типами (например, intи логическое) и ссылочными типами (любой класс ). Только ссылочные типы являются частными схемами наследования, производной от java.lang.Object. В Scala все наследуются от класса верхнего уровня Любой, непосредственными дочерними элементами которого являются AnyVal(типы значений, такие как Intи Boolean) и AnyRef(ссылочные типы, как в Java). Это означает, что различие Java между примитивными типами и упакованными типами (например, intпротив Integer) отсутствует в Scala; упаковка и распаковка полностью прозрачны для пользователя. Scala 2.10 позволяет пользователю определять новые типы значений.
Вместо циклов Java «foreach » для обхода итератора в Scala есть для-выражений, которые аналогичны в перечислить понимание в таких языках, как Haskell, или комбинацию представлений списков и выражений генератора в Python.Для-использования с использованием ключевого слова yieldпозволяют сгенерировать новую коллекцию путем итерации по существующей, возвращая новую коллекцию того же типа. Они преобразуются компилятором в серию вызовов map, flatMapи filter. Если yieldне используется, приближается к циклу стиля императивного преобразования путем преобразования в foreach.
. Простой пример:
val s = for (x <- 1 to 25 if x*x>50) yield 2 * x
Результатом выполнения будет следующий:
Vector (16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50)(Обратите внимание, что выражение от 1 до 25не является специальным синтаксисом. Метод от доскорее определен в стандартной библиотеке Scala как метод расширения для целых чисел, используя технику, известную как неявные преобразования, которая позволяет добавлять новые методы к существующим типам.)
Более сложным примером итерации по карте является:
// Дана карта, определяющая Пользователи Twitter, указанные в наборе твитов, // и количество раз, когда каждый пользователь был упомянут, ищет пользователей // на карте известных политиков и возвращают новую карту, содержащую только // демократических политиков (скорее как как объекты чем струны). val dem_mentions = for {(упоминание, раз) <- mentions account <- accounts.get(mention) if account.party == "Democratic" } yield (account, times)Выражение (упоминание, раз) <- mentionsявляется примером сопоставления с образцом (см. ниже). Итерация по карте возвращает набор кортежей ключ-значение, а сопоставление с образцом позволяет легко деструктурировать кортежи на отдельные переменные для ключа и значения. Точно так же результат понимает также возвращает кортежи «ключ-значение», которые автоматически встраиваются в карту, поскольку исходный объект (из альтернатив определяет) является картой. Обратите внимание, что если укажитевместо списка, набора, массива или другой коллекции кортежей, точно такой же код, приведенный выше, даст новую коллекцию того же типа.
Поддерживая все объектно-ориентированные функции, доступные в Java (и фактически расширяя их методы), Scala также предоставляет большое количество возможностей, которые обычно встречаются только на языках функционального программирования. Вместе они позволяют писать программы Scala в почти полностью функциональном стиле, а также позволяют смешивать функциональные и функционально-ориентированные стили.
Примеры:
В отличие от C или Java, но подобно языкам, таким как Lisp, Scala не делает различий между операторами и выражениями. Функции, которые были бы объявлены как возвращающие значение voidв C или Java, и такие операторы, как в то время как, которые логически не возвращают значение, считаются в Scala возвращающие тип Unit, который является одноэлементным типом , только с одним объектом этого типа. торые вообще никогда не возвращают (например, throwope rator или функция, которая всегда выходит из нелокально с помощью исключения) логически имеют тип возврата Ничего, особый тип, не нарушены объекты; то есть нижний тип , т.е. подкласс всех типов типов. (Это, в свою очередь, делает тип Ничегосовместимым с каждым типом, позволяя вывод типа функционировать правильно.)
Аналогично, if-then-else«оператор» на самом деле является выражением, которое производит значение, то есть результат вычисления одной из двух ветвей. Это означает, что такой блок кода можно вставить везде, где требуется выражение, устранение необходимости в тернарном операторе в Scala:
// Java: int hexDigit = x>= 10? х + 'А' - 10: х + '0'; | // Scala: val hexDigit = if (x>= 10) x + 'A' - 10 else x + '0' |
По тем же причинам операторы returnне нужны в Scala, и фактически обескуражены. Как и в Лиспе, последнее выражение в блоке кода является значением этого блока кода, и если блок кода является телом функции, он будет возвращен функцией.
Чтобы прояснить, что все функции являются выражениями, даже методы, возвращающие Unit, записываются со знаком равенства
def printValue (x: String): Unit = {println ("Я съел % s ".format (x))}или аналогичный (с выводом типа и опуская ненужные фигурные скобки):
def printValue (x: String) = println (" Я съел% s "формат x)Из-за вывода типа тип числа, возвращаемые значения функции и многие другие выражения обычно могут быть опущены, поскольку компилятор может это определить. Примеры: val x = "foo"(для сохранения значения константы или внестияемого объекта ) или var x = 1.5(для определенного значения которого может быть изменено). Вывод типа в Scala по существу локальным, в отличие от более глобального алгоритма Хиндли-Милнера, используемого в Haskell, ML и других более функциональных языках. Это сделано для облегчения объектно-ориентированного программирования. В результате все еще необходимо объявить функции и типы, возвращаемые рекурсивными функциями ), например
def formatApples (x: Int) = "Я съел% d яблок".format (x)
или (с возвращаемым типом, объявленным для рекурсивной функции)
def factorial (x: Int): Int = if (x == 0) 1 else x * factorial (x - 1)
В Scala функции являются объектами, и существует удобный синтаксис для инструкций анонимных функций. Примером может представить выражение x =>x <2, которое показывает функцию с одним параметром, которое сравнивает аргумент, чтобы увидеть, меньше ли он 2. Это эквивалентно лисповской форме (лямбда (x) ( <х 2)). Обратите внимание, что ни тип x, ни тип возвращаемого значения не требуется явно указывать, как правило, это можно сделать с помощью вывода типа ; но они могут быть указаны явно, например как (x: Int) =>x <2или даже (x: Int) =>(x < 2): Boolean.
Анонимные функции ведут себя как истинные замыкание в том смысле, что они автоматически захватить любые переменные, которые автоматически доступны в среде включающей функции. даже такие переменные можно изменить, если они изменяемы, и измененное значение будет доступно при вызове следующего анонимной функции.)
Еще более короткая форма анонимной функции использует переменные-заполнители : Например, следующее:
карта списка {x =>sqrt (x)}может быть записана более кратко как
карта списка {sqrt (_)}или даже
карта списка sqrtScala обеспечивает различие между изменяемыми переменными переменными. а var, а неизменяемые значения объявляются с использованием использования слова val. Переменная, объявленная с использованием ключевого слова val, не может быть переназначена так же, как переменная, объявленная с использованием ключевого слова final, не может быть переназначена в Java. Однако следует отметить, что valиспользуется только поверхностно, то есть объект, на который указанный val, не гарантирует неизменяемость самого себя.
Неизменяемые классы используются по соглашению, а стандартная библиотека Scala использует набор классов коллекция. Scala предоставляет изменяемые варианты классов коллекций, а загружаемая версия всегда используется, если изменяемая версия не импортирована явно. Неизменяемые варианты - это постоянные структуры данных, которые всегда возвращают обновленную копию старого объекта вместо деструктивного обновления старого объекта на месте. Пример этого элемента выполнен в соответствии со списком, где добавление элемента к списку выполняется путем возврата нового списка, состоящего из элемента и ссылок на конец списка. Может быть выполнено только добавление всех элементов в старом списке к новому списку. Таким же образом, вставка элемента в середину списка. Это называется структурным разделением. Это обеспечивает очень простой параллелизм - блокировки не требуются, поскольку никакие общие объекты никогда не изменяются.
По умолчанию оценка является строгой («нетерпеливой»). Другими словами, Scala оценивает выражение, как только они становятся доступными, а не по мере необходимости. Можно объявить переменную нестрогой («ленивой») с помощью ключевого слова ленивый, означающий, что код для определения значения не будет оцениваться до первого обращения к переменной. Также существуют нестрогие коллекции различных типов (например, тип Stream, нестрогий связанный список), и любую коллекцию можно сделать нестрогой с помощью метода view. Нестрогие коллекции хорошее семантическое соответствие таким вещам, как данные, создаваемые сервером, где оценка кода для генерации более поздних элементов списка (что, в свою очередь, запускает запрос к серверу, возможно, расположенному где-то еще в Интернете). происходит, когда элементы действительно нужны.
Функциональные языки обычно используются оптимизацию хвостового вызова, что позволяет широко использовать рекурсию без переполнения стека проблемы. Ограничения байт-кода Java усложняют оптимизацию хвостового вызова на JVM. В общем, функция, которая вызывает себя с хвостовым вызовом, может быть оптимизирована, а взаимно рекурсивные функции - нет. Батуты были предложены как обходной путь. Поддержка батутов обеспечивается библиотекой Scala с объектом scala.util.control.TailCallsначиная с Scala 2.8.0 (выпущенной 14 июля 2010 г.). Функция может быть дополнительно аннотирована с помощью @tailrec, и в этом случае она не будет компилироваться, если она не является хвостовой рекурсивной.
Scala имеет встроенные в поддержке сопоставления с образцом, которое можно рассматривать как более сложную, расширяемую версию оператора switch, где могут быть сопоставлены произвольные типы данных (а не просто простые типы, такие как целые числа, логические и строки), включая произвольную типы вложений. Предоставляется специальный тип класса, известный как класс case, который включает автоматическую поддержку сопоставления с образцом и может быть модели для моделирования алгебраических типов данных, используемых во многих языках функционального программирования. (С точки зрения Случай Scala класс - это просто обычный класс, для которого также могут быть предоставлены различные варианты поведения, которые могут быть предоставлены вручную, методы определения, обеспечивают глубокое сравнение и хеширование, а также деструктуризацию класса в его конструкторе параметров. во время сопоставления с образцом.)
Пример определения алгоритма quicksort с использованием сопоставления с образцом:
def qsort (list: List [Int]): List [Int] = соответствие списку {case Nil =>Nil case pivot :: tail =>val (меньше, остальное) = tail.partition (_ < pivot) qsort(smaller) ::: pivot :: qsort(rest) }Идея в том, что мы разбиваем список на элементы, меньшие, чем точка поворота и элементы не меньше, рекурсивно результаты сортировать каждую часть и вставлять вместе с точкой поворота между ними. 25>совпадениеo perator используется для сопоставления с образцом объекта, хранящегося в list. Каждое выражение caseпо очереди проверяется, будет ли оно совпадать, и первое совпадение определяет результат. В этом случае Nilсоответствует только литеральному объекту Nil, но pivot :: tailсоответствует непустому списку и одновременно разрушает список в соответствии с образец дан. В этом случае связанный код будет иметь доступ к локальной переменной с именем pivot, содержащей заголовок списка, и другой переменной tail, содержащей конец списка. Обратите внимание, что эти переменные доступны только для чтения и семантически очень похожи на привязки переменных , устанавливаемые с помощью оператора let в Lisp и Scheme.
Сопоставление с образцом также происходит в объявлениях локальных переменных. В этом случае возвращаемое значение вызова tail.partition- это кортеж - в данном случае два списка. (Кортежи отличаются от других типов контейнеров, например списков, тем, что они всегда имеют фиксированный размер, а элементы могут быть разных типов - хотя здесь они оба одинаковы.) Сопоставление с образцом - самый простой способ получить две части кортеж.
Форма _ < pivotпредставляет собой объявление анонимной функции с переменной-заполнителем; см. раздел выше об анонимных функциях.
Операторы списка ::(которые добавляют элемент в начало списка, аналогично consв Lisp и Scheme) и :::(который объединяет два списка, аналогично appendв Lisp и Scheme) оба появляются. Несмотря на внешний вид, ни в одном из этих операторов нет ничего «встроенного». Как указано выше, любая строка символов может служить именем функции, а метод, применяемый к объекту, может быть записан в стиле «infix » без точки или круглых скобок. Строку выше, как написано:
qsort (меньше) ::: pivot :: qsort (rest)можно также записать так:
qsort (rest).: :( pivot). :: :( qsort (меньше))в более стандартной записи вызова метода. (Методы, заканчивающиеся двоеточием, являются правоассоциативными и привяжите к объекту справа.)
В приведенном выше примере сопоставления с образцом тела оператора соответствиеявляется частичным функция, которая состоит из выражений делас преобладающим предварительным соглашением выражением, аналогично телу оператора switch. Частичные функции также используются в части обработки исключений оператора try:
try {...} catch {case nfe: NumberFormatException =>{println (nfe); List (0)} case _ =>Nil}Наконец, частичную функцию можно использовать отдельно, и результат ее эквивалентен выполнению сопоставлениянад ней. Например, предыдущий код для quicksort может быть записан так:
val qsort: List [Int] =>List [Int] = {case Nil =>Nil case pivot :: tail =>val (меньше, остальное) = tail.partition (_ < pivot) qsort(smaller) ::: pivot :: qsort(rest) }Здесь объявляется переменная только для чтения, тип функции от списков целых чисел до списков целых чисел и связывает ее с частичной функцией (обратите внимание, что единственный параметр частичной функции никогда явно не объявляется Однако мы все равно вызываем эту переменную точно так же, если бы это была обычная функция:
scala>qsort (List (6,2,5,9)) res32: List [Int] = List (2, 5, 6, 9)
Scala - это чистый объектно-ориентированный язык в том смысле, что каждое значение является объект. Типы данных и поведение объектов описываются классами и чертами. Абстракции классов расширяются подклассом и с помощью гибкого механизма композиции на основе mixin, чтобы избежать проблем множественного наследования.
Traits являются Scala заменой интерфейсов Java. Интерфейсы в версиих Java до 8 сильно ограничены и могут содержать только объявления абстрактных функций. Новые методы использования методов в интерфейсе неудобно (одни и те же методы повторно реализованы в каждой реализации). Черты похожи на классы mixin в том, что они обладают почти всеми мощью обычного обычного класса, не имея только параметры класса (эквивалент Scala параметров конструктора Java), поскольку черты всегда доступны с классом. Оператор superведет себя особым образом в признаках, позволяя объединять признаки в цепочку с использованием композиции в дополнение к наследованию. Следующий пример представляет простую оконную систему:
абстрактный класс Window {// abstract def draw ()} class SimpleWindow extends Window {def draw () {println ("in SimpleWindow") // собой рисование основного окна}} признак WindowDecoration extends Window {} trait HorizontalScrollbarDecoration расширяет WindowDecoration {// здесь необходимо "абстрактное переопределение", чтобы "super ()" работала, потому что родительская // функция является абстрактной. Если бы он был конкретным, было бы достаточно обычного «переопределения». абстрактное переопределение def draw () {println ("в HorizontalScrollbarDecoration") super.draw () // теперь рисуем горизонтальную полосу прокрутки}} trait VerticalScrollbarDecoration расширяет WindowDecoration {абстрактное переопределение def draw () {println ("in VerticalScrollbarDecoration") super.draw () // теперь рисуем вертикальную полосу прокрутки}} trait TitleDecoration extends WindowDecoration {abstract override def draw () {println ("in TitleDecoration") super.draw () // теперь рисуем на название заголовка}}Переменная может быть объявлено следующим образом:
val mywin = new SimpleWindow с VerticalScrollbarDecoration с HorizontalScrollbarDecoration с TitleDecoration
Результатом вызова mywin.draw ()будет:
в TitleDecoration в HorizontalScrollbarDecoration в VerticalScrollbarDecorationDecoration>drawсначала выполнил код вTitleDecoration(последний смешанный признак), (через вызовыsu per ()) проходит через другие смешанные черты и ev в соответствии с кодом вWindow, даже если ни одна из черт не унаследована друг от друга. Это похоже на шаблон декоратора , но является более кратким и менее подверженным ошибкам, поскольку не требует явной инкапсуляции родительского окна, явной пересылки функций, реализации которых не изменена, или использования функций запуска -время инициализации отношений сущностей. На других языках аналогичный эффект может быть достигнут во время компиляции с длинной линейной цепочкой наследование реализации, но с недостатком по сравнению со Scala, что для каждой комбинации нужно объявлять одну линейную цепочку наследований. добавлений.Система характерных типов
Scala оснащена системой выразительных типов, которые в основном используются и связное использование абстракций. Однако система типов - это не звук. В частности, система типов поддерживает:
Scala может выводить типы по использованию. Это делает большинство объявлений статических типов необязательных. Статические типы необязательно объявлять явно, если ошибка компилятора не указывает на необходимость. На практике некоторые статические типы включенных в ясности объявления кода.
Распространенный метод в Scala, известный как «обогатить мою библиотеку» (названный Мартином Одерски в 2006 году «прокачать мою библиотеку»); коннотации и незрелость), позволяет использовать новые методы, как если бы они были добавлены к существующим типам. Это похоже на концепцию C # методы расширения, но более мощный, потому что метод не ограничивается добавлением методов и может быть, например, агент для использования новых интерфейсов. В Scala этот метод включает объявление неявного преобразования из типа, «принимающего» метод, в новый тип (обычно класс), обертывает исходный тип и дополнительный метод. Если метод не может быть найден для данного типа, компилятор автоматически ищет любые применимые неявные преобразования к типам, которые рассматриваемый метод.
Этот метод позволяет новые методы к существующему классу с использованием дополнительной библиотеки, так что только код, который импортирует дополнительную библиотеку, получает новую функциональность, весь другой код не исследуется.
В следующем примере обогащения типа Intметоды isEvenи isOdd:
объект MyExtensions {неявный класс IntPredicates (i: Int) {def isEven = i% 2 == 0 def isOdd =! isEven}} import MyExtensions._ // привносим неявное обогащение в области видимости 4. isEven // ->trueИмпорт членов MyExtensionsприносит неявное преобразование в класс расширения IntPredicatesв области видимости.
Стандартная библиотека Scala включает поддержку моделей акторов в дополнение к стандартным API-интерфейсам параллелизма Java. Lightbend Inc. предоставляет платформу, которая включает Akka, отдельную платформу с открытым исходным кодом, обеспечивает параллелизм на основе акторов. Акторы Akka могут быть распределены или объединены с программной транзакционной памятью (транзакторы). Альтернативные реализации взаимодействующих последовательных процессов (CSP) для передачи сообщений на основе канала - это взаимодействие с объектами Scala или просто через JCSP.
Актер подобен экземпляру с почтовым ящиком. Его можно создать с помощью system.actorOf, переопределив метод получитьдля получения сообщений и используя метод !(восклицательный знак) для отправки сообщения. В следующем изображении показан EchoServer, который может получать сообщения и затем распечатывать их.
val echoServer =actor (new Act {стать {case msg =>println ("echo" + msg)}}) echoServer! "hi"Scala также имеет встроенную поддержку параллельного программирования с использованием параллельных коллекций, интегрированных в его стандартную библиотеку, начиная с версии 2.9.0.
В следующем примере, как использовать параллельные коллекции для повышения производительности.
val urls = List ("https://scala-lang.org", "https://github.com/scala/ scala") def fromURL (url: String) = scala.io.Source.fromURL ( URL).getLines (). mkString ("\ n") val t = System.currentTimeMillis () urls.par.map (fromURL (_) // par возвращает параллельную работу коллекции println ("time:" + (System.currentTimeMillis - t) + "ms ")Помимо поддержки акторов и параллелизма данных, Scala также поддерживает асинхронное программирование с Futures и Promises, программную транзакционную память и потоки событий.
Наиболее подходящим решением для кластерных вычислений с открытым исходным кодом, написанным на Scala, является Apache Spark. Кроме того, Apache Kafka, очередь сообщений публикация– подписка , популярная в Spark и других технологиях обработки, написана на Scala.
Есть несколько способов протестировать код в Scala. поддерживает несколько стилей тестирования и может интегрироваться со средами тестирования на основе Java. - это библиотека, аналогичная Haskell QuickCheck. это библиотека для написания исполняемых спецификаций программного обеспечения. обеспечивает поддержку тестирования высокоуровневых и каррированных функций. JUnit и TestNG - тестовые популярные среды, написанные на Java.
| Версия | Выпущенные | Функции | Статус |
|---|---|---|---|
| 1.0.0-b2 | 8 декабря- 2003 | _ | _ |
| 1.1.0-b1 | 19 февраля 2004 г. |
| _ |
| 1.1.1 | 23 марта 2004 г. |
| _ |
| 1.2.0 | 9-Июнь 2004 г. |
| _ |
| 1.3.0 | 16 сентября 2004 г. |
| _ |
| 1.4.0 | 20 июня 2005 г. |
| _ |
| 2.0 | 12 марта 2006 г. |
| _ |
| 2.1.0 | 17 марта 2006 г. |
| _ |
| 2.1.8 | 23- Август 2006 г. |
| _ |
| 2.3.0 | 23 ноября 2006 г. |
| _ |
| 2.4.0 | 09-март-2007 |
| _ |
| 2.5.0 | 02-мая -2007 |
| _ |
| 2.6.0 | 27 июля 2007 г. |
| _ |
| 2.7.0 | 07 февраля 2008 г. |
| _ |
| 2.8.0 | 14 июля 2010 г. |
| _ |
| 2.9.0 | 12 мая 2011 г. г. |
| _ |
| 2.10 | 04-янв-2013 |
Экспериментальные возможности
| _ |
| 2.10.2 | 06-июн-2013 | _ | _ |
| 2.10.3 | 01-окт. 2013 | _ | _ |
| 2.10.4 | 18 марта 2014 г. | _ | _ |
| 2.10.5 | 05 марта 2015 | _ | _ |
| 2.11.0 | 21 апреля -2014 |
| _ |
| 2.11.1 | 20 мая 2014 года | _ | _ |
| 2.11.2 | 22 июля- 2014 | _ | _ |
| 2.11.4 | 31 октября 2014 года | _ | _ |
| 2.11.5 | 08 января 2015 | _ | _ |
| 2.11.6 | 05 марта -2015 | _ | _ |
| 2.11.7 | 23 июня 2015 | _ | _ |
| 2.11.8 | 08 марта 2016 | _ | _ |
| 2.11.11 | 18-Апр-2017 | _ | _ |
| 2.11.12 | 13-ноя-2017 | _ | _ |
| 2.12.0 | 03-ноя-2016 |
| _ |
| 2.12. 1 | 05-дек-2016 | _ | _ |
| 2.12.2 | 18 апреля 2017 г. | _ | _ |
| 2.12.3 | 26 июля 2017 г. | _ | _ |
| 2.12.4 | 17 -Окт-2017 | _ | _ |
| 2.12.5 | 15-мар-2018 | _ | _ |
| 2.12.6 | 27-апр- 2018 | _ | _ |
| 2.12.7 | 27-сен-2018 | _ | _ |
| 2.12.8 | 04-дек-2018 | Первый выпуск Scala 2.12 с лицензией, измененной на Apache v2.0 | _ |
| 2.13.0 | 11-июн-2019 | _ | Текущее |
Scala часто сравнивают с Groovy и Clojure, двумя другими программами также используют JVM. Существенные различия между этими языками существуют в системе, в которой каждый язык поддерживает ориентированное и функциональное программирование, и в сходстве их синтаксиса с синтаксисом Java.
Scala имеет статическую типизацию, тогда как Groovy и Clojure динамически типизированы. Это делает систему более сложной и трудной для понимания, но позволяет выявлять почти все ошибки типов во время компиляции. Напротив, динамическая типизация требует большего количества тестов для правильной программы и, как правило, медленнее, чтобы обеспечить большую гибкость и простоту программирования. Что касается разницы в скорости, текущие версии Groovy и Clojure допускают необязательные аннотации типов, чтобы помочь программам избежать накладных расходов на динамическую типизацию в случаях, когда типы практически статичны. Эти накладные параметры расширенной программы расширены при использовании версий JVM, которые были расширены с помощью динамических вызовов для методов, которые используются с динамическими типизированными аргументами. Эти достижения сокращают разрыв в скорости между статической и динамической типизацией, хотя язык со статической типизацией, как Scala, по-прежнему является предпочтительным выбором, когда эффективность выполнения очень важна.
Что касается парадигм программирования, Scala наследует объектно-ориентированную модель Java и расширяет ее способы. Отличный, хотя и сильно объектно-ориентирован, больше ориентирован на снижение многословности. В Clojure объектно-ориентированному программированию не уделяется должного внимания, поскольку функциональное программирование является основным вниманием языка. Scala также имеет много средств функционального программирования, включая функции включения в продвинутых языках, таких как Haskell, пытается быть агностиком между двумя парадигмами, позволяя разработчику выбирать между двумя парадигмами или, что чаще, их комбинацией.
Что касается синтаксического сходства с Java, Scala наследует большую часть синтаксиса Java, как и в случае с Groovy. Clojure, с другой стороны, следует синтаксису Lisp, который отличается как по внешнему виду, так и по философии. Однако изучение Scala также считается трудным из его множества продвинутых функций. Это не относится к Groovy, как он использует язык.
По состоянию на 2013 год все языки на основе JVM (Clojure, Groovy, Kotlin, Scala) значительно менее популярны, чем исходный язык Java, который обычно первое занимает или второе место, которое также развивается с течением времени.
Индекс популярности языков программирования, который отслеживает поисковые запросы языковых руководств, в апреле 2018 года поставил Scala на 15-е место с небольшой тенденцией к снижению. Это делает Scala самым популярным языком на основе JVM после Java, хотя сразу за ним следует Kotlin, язык на основе JVM, который занимает 16-е место с сильной тенденцией к росту.
Индекс TIOBE популярности языков программирования использует рейтинг в поисковых системах и аналогичный подсчет публикаций для определения популярности языка. По состоянию на апрель 2018 года Scala заняла 34-е место, опустившись на четыре позиции за последние два года, но - как упоминалось в разделе «Ошибки и запросы на изменение» - TIOBE знает о проблемах с его методологией использования поисковых запросов, которые могут не обычно используется в некоторых сообществах языков программирования. В этом рейтинге Scala опережает некоторые функциональные языки, такие как Haskell (42-й), Erlang, но ниже других языков, таких как Swift (15-е), Perl. (16-е), Go (19-е) и Clojure (30-е).
ThoughtWorks Technology Radar, представляющий собой полугодовой отчет группы старших технологов, основанный на мнениях, рекомендовал принятие Scala в категории языков и фреймворков в 2013 году. В июле 2014 года эта оценка была сделан более конкретным и теперь относится к «Scala, хорошие части», который описывается как «Чтобы успешно использовать Scala, вам необходимо изучить язык и иметь очень твердое мнение о том, какие части вам подходят, создав свое собственное определение. Scala, хорошие части ".
Рейтинг языков программирования RedMonk, который устанавливает рейтинг на основе количества проектов GitHub и вопросов, заданных на Stack Overflow, занимает у Scala 14 место. Здесь Scala помещается в группу языков второго уровня - впереди Go, PowerShell и Haskell и позади Swift, Objective-C <56.>, Машинопись и R. Однако в своем отчете за 2018 год рейтинг Scala в третий раз подряд отметил падение рейтинга, поставив под вопрос, «сколько из доступного кислорода для Scala потребляется Kotlin, поскольку последний продолжает подниматься в этом рейтинге».
В исследовании «Состояние Java» за 2018 год, в котором были собраны данные от 5160 разработчиков по различным темам, связанным с Java, Scala занимает третье место с точки зрения использования альтернативных языков в JVM. По сравнению с прошлогодним опросом, использование Scala среди альтернативных языков JVM упало почти на четверть (с 28,4% до 21,5%), обогнав Kotlin, который вырос с 11,4% в 2017 году до 28,8% в 2018 году.
В марте 2015 года бывший вице-президент группы Platform Engineering в Twitter Раффи Крикориан, заявил, что не выбрал бы Scala в 2011 году из-за его кривой обучения. В том же месяце старший вице-президент LinkedIn Кевин Скотт заявил о своем решении «минимизировать [свою] зависимость от Scala». В ноябре 2011 года Yammer отошел от Scala по причинам, в том числе из-за необходимости обучения новых членов команды и несовместимости от одной версии компилятора Scala к другой.
Портал бесплатного программного обеспечения с открытым исходным кодом 
Портал компьютерного программирования  | В Викиучебнике есть книга по теме: Scala |
