Скала (язык программирования)

Информацию о программном обеспечении для создания музыкальных гамм см. в разделе Scala (программное обеспечение) .

Скала

Парадигма	Мультипарадигмальность : параллельная , функциональная , императивная , объектно-ориентированная.
Разработано	Мартин Одерски
Разработчик	Лаборатория методов программирования Федеральной политехнической школы Лозанны
Впервые появился	20 января 2004 г ( 20 января 2004 г. )
Стабильная версия	3.4.0   / 29 февраля 2024 г ( 29 февраля 2024 г. )
Дисциплина набора текста	Предполагаемый , статический , сильный , структурный.
Язык реализации	Скала
Платформа	Виртуальная машина Java (JVM) JavaScript ( Scala.js ) LLVM ( Scala Native ) (экспериментальный)
Лицензия	Апач 2.0
Расширения имен файлов	.скала, .sc
Веб-сайт	www .scala-lang .org
Под влиянием
Общий Лисп , Эйфель , Эрланг , F# , Хаскелл , Ява , ОКамл , Оз , Пицца , Схема , Smalltalk , стандартный ML
Под влиянием
Ceylon , Chisel , Fantom , F# , C# , Kotlin , Lasso , Red , Flix
Скала в Wikibooks

Скала ( / ˈ s k ɑː l ɑː / SKAH -lah ) — сильный статически типизированный высокого уровня язык программирования общего назначения , поддерживающий как объектно-ориентированное, так и функциональное программирование . Разработанный, чтобы быть кратким, многие дизайнерские решения Scala направлены на устранение критики в адрес Java .

Исходный код Scala можно скомпилировать в байт-код Java и запустить на виртуальной машине Java (JVM). Scala также можно транспилировать в JavaScript для запуска в браузере или скомпилировать непосредственно в собственный исполняемый файл. При работе на JVM Scala обеспечивает совместимость языков с Java , так что на библиотеки, написанные на любом языке, можно напрямую ссылаться в коде Scala или Java. Как и Java, Scala является объектно-ориентированным и использует синтаксис, называемый фигурными скобками который похож на язык C. , также существует возможность использовать правило off-side (отступы) Начиная с Scala 3, для структурирования блоков , и его использование рекомендуется. Мартин Одерски сказал, что это оказалось самым продуктивным изменением, представленным в Scala 3.

В отличие от Java, Scala имеет множество функций программирования функциональных языков (таких как Scheme , Standard ML и Haskell ), включая каррирование , неизменяемость , отложенное вычисление и сопоставление с образцом . Он также имеет расширенную систему типов, поддерживающую алгебраические типы данных , ковариацию и контравариантность , типы более высокого порядка (но не типы более высокого ранга ), анонимные типы , перегрузку операторов , необязательные параметры , именованные параметры , необработанные строки и экспериментальную версию только для исключений. версия алгебраических эффектов, которую можно рассматривать как более мощную версию проверяемых исключений Java .

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

История

Разработка Scala началась в 2001 году в Федеральной политехнической школе Лозанны (EPFL) (в Лозанне , Швейцария ) Мартином Одерски . Он стал продолжением работы над Funnel, языком программирования, сочетающим в себе идеи функционального программирования и сетей Петри . Одерский ранее работал над Generic Java и javac , компилятором Java компании 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 .

По состоянию на июнь 2024 г. Разработчики Scala планируют выпустить версию 3.6 к концу 2024 года. Они концентрируются на улучшении ряда функций, таких как сокращение времени сборки, достижение более тесной интеграции с инструментами, улучшение пользовательского опыта (UX), улучшение отчетности и совершенствование стабильность и точность компилятора.

Платформы и лицензия

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

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

Другие компиляторы и цели

Scala.js — это компилятор Scala, который компилируется в JavaScript, что позволяет писать программы Scala, которые могут работать в веб-браузерах Node.js. или Компилятор, находящийся в разработке с 2013 года, был объявлен неэкспериментальным в 2015 году (версия 0.6). Версия v1.0.0-M1 была выпущена в июне 2018 года, а версия 1.1.1 — в сентябре 2020 года.

Scala Scala Native — это компилятор , предназначенный для инфраструктуры компилятора LLVM для создания исполняемого кода, использующего облегченную управляемую среду выполнения, использующую сборщик мусора Boehm . Проект возглавляет Денис Шабалин, и его первый выпуск, 0.1, вышел 14 марта 2017 года. Разработка Scala Native началась в 2015 году с целью сделать быстрее, чем компиляция «точно в срок» компиляцию JVM , исключив начальную компиляцию во время выполнения. код, а также предоставляет возможность напрямую вызывать собственные процедуры.

Эталонный компилятор Scala, ориентированный на .NET Framework и его среду Common Language Runtime, был выпущен в июне 2004 года. но официально от него отказались в 2012 году.

Примеры

Пример «Привет, мир»

Программа Hello World, написанная на Scala 3, имеет следующую форму:

@main def main() = println("Hello, World!")

В отличие от автономного приложения Hello World для Java , здесь нет объявления класса и ничего не объявлено как статическое.

Когда программа сохраняется в файле HelloWorld.scala , пользователь компилирует ее командой:

$ scalac HelloWorld.scala

и запускает его с

$ scala HelloWorld

Это аналогично процессу компиляции и запуска кода Java. Действительно, модель компиляции и выполнения Scala идентична модели Java, что делает ее совместимой с инструментами сборки Java, такими как Apache Ant .

Укороченная версия программы «Hello World» на Scala:

println("Hello, World!")

Scala включает интерактивную оболочку и поддержку сценариев. Сохранено в файле с именем HelloWorld2.scala, это можно запустить как скрипт с помощью команды:

$ scala HelloWorld2.scala

Команды также можно вводить непосредственно в интерпретатор Scala, используя опцию -е :

$ scala -e 'println("Hello, World!")'

Выражения можно вводить в REPL интерактивно :

$ scala
Welcome to Scala 2.12.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_131).
Type in expressions for evaluation. Or try :help.

scala> List(1, 2, 3).map(x => x * x)
res0: List[Int] = List(1, 4, 9)

scala>

Базовый пример

В следующем примере показаны различия между синтаксисом Java и Scala. Функция mathFunction принимает целое число, возводит его в квадрат, а затем добавляет кубический корень этого числа к натуральному логарифму этого числа, возвращая результат (т. е. $n^{2/3}+\ln(n^{2})$):

// Java: int mathFunction(int num) { int numSquare = num*num; return (int) (Math.cbrt(numSquare) + Math.log(numSquare)); }
// Scala: Direct conversion from Java // no import needed; scala.math // already imported as `math` def mathFunction(num: Int): Int = var numSquare: Int = num*num return (math.cbrt(numSquare) + math.log(numSquare)). asInstanceOf[Int]	// Scala: More idiomatic // Uses type inference, omits `return` statement, // uses `toInt` method, declares numSquare immutable import math._ def mathFunction(num: Int) = val numSquare = num*num (cbrt(numSquare) + log(numSquare)).toInt

Некоторые синтаксические различия в этом коде:

• Scala не требует точки с запятой (;) для завершения операторов.
• Типы значений пишутся с заглавной буквы (регистр предложений): Int, Double, Boolean вместо int, double, boolean.
• Типы параметров и возвращаемых значений следуют, как в Pascal , а не предшествуют, как C. в
• Методам должно предшествовать def.
• Локальным переменным или переменным класса должно предшествовать val (указывает неизменяемую переменную) или var (указывает на изменяемую переменную).
• The return оператор в функции не нужен (хотя и разрешен); значением последнего выполненного оператора или выражения обычно является значение функции.
• Вместо оператора приведения Java (Type) foo, Scala использует foo.asInstanceOf[Type]или специализированную функцию, такую ​​как toDouble или toInt.
• Вместо Java 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<String>.
• Вместо псевдотипа void, в Scala есть настоящий одноэлементный класс Unit (см. ниже).

Пример с классами

В следующем примере сравниваются определения классов в Java и Scala.

// Java: public class Point { private double x, y; public Point(final double x, final double y) { this.x = x; this.y = y; } public Point( double x, double y, boolean addToGrid ) { this(x, y); if (addToGrid) grid.addPoint(this); } public Point() { this(0.0, 0.0); } private void addPoint(Point p) { x += p.x; y += p.y; } public double getX() { return x; } public double getY() { return y; } double distanceToPoint(final Point other) { return distanceBetweenPoints(x, y, other.x, other.y); } private static Point grid = new Point(); static double distanceBetweenPoints( final double x1, final double y1, final double x2, final double y2 ) { return Math.hypot(x1 - x2, y1 - y2); } }

// Scala class Point( var x: Double, var y: Double, addToGrid: Boolean = false ): import Point._ def += (p: Point) = x += p.x y += p.y if (addToGrid) grid += this def this() = this(0.0, 0.0) def distanceToPoint(other: Point) = distanceBetweenPoints(x, y, other.x, other.y) end Point object Point: private val grid = new Point() def distanceBetweenPoints(x1: Double, y1: Double, x2: Double, y2: Double) = math.hypot(x1 - x2, y1 - y2)

В приведенном выше коде показаны некоторые концептуальные различия между обработкой классов в Java и Scala:

• В Scala нет статических переменных или методов. Вместо этого у него есть одноэлементные объекты , которые по сути являются классами только с одним экземпляром. Одиночные объекты объявляются с использованием object вместо class. Обычно статические переменные и методы размещаются в одноэлементном объекте с тем же именем, что и имя класса, который затем называется сопутствующим объектом . (Базовый класс для одноэлементного объекта имеет $ добавлено. Следовательно, для class Foo с сопутствующим объектом object Foo, под капотом класс Foo$ содержащий код сопутствующего объекта, и создается один объект этого класса с использованием шаблона Singleton .)
• Вместо параметров конструктора в Scala есть параметры класса , которые размещаются в классе, подобно параметрам функции. При объявлении с помощью val или var модификатор, поля также определяются с тем же именем и автоматически инициализируются из параметров класса. (Под капотом внешний доступ к общедоступным полям всегда осуществляется через методы доступа (getter) и мутатора (setter), которые создаются автоматически. Функция доступа имеет то же имя, что и поле, поэтому в приведенном выше примере нет необходимости явно объявляйте методы доступа.) Обратите внимание, что альтернативные конструкторы также могут быть объявлены, как в Java. Код, который будет входить в конструктор по умолчанию (кроме инициализации переменных-членов), выполняется непосредственно на уровне класса.
• В Scala можно определять операторы, используя символы в качестве имен методов. Вместо addPoint, пример Scala определяет +=, который затем вызывается с инфиксной записью как grid += this.
• Видимость по умолчанию в Scala: public.

Возможности (применительно к Java)

Scala имеет ту же модель компиляции, что и Java и C# , а именно раздельную компиляцию и динамическую загрузку классов , так что код Scala может вызывать библиотеки Java.

Рабочие характеристики Scala такие же, как у Java. Компилятор Scala генерирует байт-код, который почти идентичен тому, который генерирует компилятор Java. Фактически, код Scala можно декомпилировать в читаемый код Java, за исключением некоторых операций конструктора. Для виртуальной машины Java (JVM) код Scala и код Java неотличимы. Единственное отличие — одна дополнительная библиотека времени выполнения. scala-library.jar.

Scala добавляет большое количество функций по сравнению с Java и имеет некоторые фундаментальные различия в базовой модели выражений и типов, которые делают язык теоретически более чистым и устраняют несколько крайних случаев в Java. С точки зрения Scala это практически важно, поскольку некоторые дополнительные функции Scala доступны и в C#.

Синтаксическая гибкость

Как упоминалось выше, Scala обладает большей синтаксической гибкостью по сравнению с Java. Ниже приведены некоторые примеры:

• Точки с запятой не нужны; строки автоматически соединяются, если они начинаются или заканчиваются токеном, который обычно не может находиться в этой позиции, или если есть незакрытые скобки или скобки.
• можно использовать любой метод В качестве инфиксного оператора , например "%d apples".format(num) и "%d apples" format num эквивалентны. Фактически, арифметические операторы, такие как + и << обрабатываются так же, как и любые другие методы, поскольку имена функций могут состоять из последовательностей произвольных символов (за некоторыми исключениями, сделанными для таких вещей, как круглые скобки и фигурные скобки, которые должны обрабатываться особым образом); единственная специальная обработка, которой подвергаются такие методы с символьными именами, касается обработки приоритета.
• Методы apply и update имеют синтаксические краткие формы. foo()-где foo — это значение (одиночный объект или экземпляр класса) — сокращение от foo.apply(), и foo() = 42 это сокращение от foo.update(42). Сходным образом, foo(42) это сокращение от foo.apply(42), и foo(4) = 2 это сокращение от foo.update(4, 2). Это используется для классов коллекций и распространяется на многие другие случаи, например, на ячейки STM .
• Шкала различает отсутствие родителей ( def foo = 42) и пустые скобки ( def foo() = 42) методы. При вызове метода с пустыми скобками круглые скобки могут быть опущены, что полезно при вызове библиотек Java, которые не знают этого различия, например, используя foo.toString вместо foo.toString(). По соглашению, метод должен определяться с пустыми скобками, когда он выполняет побочные эффекты .
• Имена методов, заканчивающиеся двоеточием ( :) ожидайте, что аргумент находится в левой части, а получатель — в правой. Например, 4 :: 2 :: Nil то же самое, что Nil.::(2).::(4), первая форма визуально соответствует результату (списку с первым элементом 4 и вторым элементом 2).
• Переменные тела класса могут быть прозрачно реализованы как отдельные методы получения и установки. Для trait FooLike { var bar: Int }, реализация может быть object Foo extends FooLike { private var x = 0; def bar = x; def bar_=(value: Int) { x = value }} } }. Сайт вызова по-прежнему сможет использовать краткую foo.bar = 42.
• При вызове методов допускается использование фигурных скобок вместо круглых. Это позволяет реализовать чисто библиотечные реализации новых структур управления. Например, breakable { ... if (...) break() ... } выглядит так, как будто breakable было ключевым словом, определяемым языком, но на самом деле это просто метод, принимающий аргумент thunk . Методы, принимающие преобразователи или функции, часто помещают их во второй список параметров, что позволяет смешивать синтаксис круглых и фигурных скобок: Vector.fill(4) { math.random } то же самое, что Vector.fill(4)(math.random). Вариант с фигурными скобками позволяет выражению занимать несколько строк.
• Выражения For (поясняются ниже) могут содержать любой тип, определяющий монадические методы, например map, flatMap и filter.

Сами по себе это может показаться сомнительным выбором, но в совокупности они служат цели, позволяющей определять предметно-ориентированные языки в Scala без необходимости расширения компилятора. Например, специальный синтаксис Erlang для отправки сообщения актору, т.е. actor ! message может быть (и реализовано) в библиотеке Scala без необходимости расширения языка.

Единая система типов

Java проводит четкое различие между примитивными типами (например, int и boolean) и ссылочные типы (любой класс ). Только ссылочные типы являются частью схемы наследования, происходящей от java.lang.Object. В Scala все типы наследуются от класса верхнего уровня. Any, чьи непосредственные дети AnyVal (типы значений, например Int и Boolean) и AnyRef (ссылочные типы, как в Java). Это означает, что различие Java между примитивными типами и коробочными типами (например, int против. Integer) нет в Scala; упаковка и распаковка полностью прозрачны для пользователя. Scala 2.10 позволяет пользователю определять новые типы значений.

For-выражения

Вместо Java- циклов foreach для обхода итератора в Scala есть for-выражения, которые похожи на генераторы списков в таких языках, как 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 to 25 не является специальным синтаксисом. Метод to скорее определен в стандартной библиотеке Scala как метод расширения целых чисел с использованием метода, известного как неявные преобразования. что позволяет добавлять новые методы к существующим типам.)

Более сложный пример перебора карты:

// Given a map specifying Twitter users mentioned in a set of tweets,
// and number of times each user was mentioned, look up the users
// in a map of known politicians, and return a new map giving only the
// Democratic politicians (as objects, rather than strings).
val dem_mentions = for 
    (mention, times) <- mentions
    account          <- accounts.get(mention)
    if account.party == "Democratic"
  yield (account, times)

Выражение (mention, times) <- mentions является примером сопоставления с образцом (см. ниже). Итерация по карте возвращает набор кортежей ключ-значение , а сопоставление с образцом позволяет легко деструктурировать кортежи на отдельные переменные для ключа и значения. Аналогичным образом, результат понимания также возвращает кортежи ключ-значение, которые автоматически встраиваются в карту, поскольку исходный объект (из переменной mentions) — это карта. Обратите внимание, что если mentions вместо того, чтобы содержать список, набор, массив или другую коллекцию кортежей, точно такой же код, указанный выше, приведет к созданию новой коллекции того же типа.

Функциональные тенденции

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

Примеры:

• Нет различия между утверждениями и выражениями
• Вывод типа
• Анонимные функции с захватом семантики (т. е. замыканиями ).
• Неизменяемые переменные и объекты
• Ленивая оценка
• Продолжения с разделителями (начиная с версии 2.8)
• Функции высшего порядка
• Вложенные функции
• каррирование
• Сопоставление с образцом
• Алгебраические типы данных (через регистровые классы )
• Кортежи

Все есть выражение

В отличие от C или Java , но подобно таким языкам, как Lisp , Scala не делает различий между операторами и выражениями . Все операторы на самом деле являются выражениями, которые возвращают некоторое значение. Функции, которые будут объявлены как возвращающие void в C или Java, а также такие операторы, как while которые логически не возвращают значение, в Scala считаются возвращающими тип Unit, который является одноэлементным типом и содержит только один объект этого типа. Функции и операторы, которые вообще никогда не возвращаются (например, throw оператор или функция, которая всегда завершается нелокально с использованием исключения) логически имеют возвращаемый тип Nothing, специальный тип, не содержащий объектов; то есть нижний тип , то есть подкласс всех возможных типов. (Это, в свою очередь, делает тип Nothing совместим со всеми типами, что позволяет вывод типа .) правильно выполнять

Аналогично, if-then-else «оператор» на самом деле является выражением, которое выдает значение, то есть результат вычисления одной из двух ветвей. Это означает, что такой блок кода можно вставить туда, где требуется выражение, что устраняет необходимость в тернарном операторе в Scala:

// Java: char hexDigit = (char)(x >= 10 ? x + 'A' - 10 : x + '0');

// Scala: val hexDigit = (if x >= 10 then x + 'A' - 10 else x + '0').toChar

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

Чтобы было понятно, что все функции являются выражениями, даже методы, возвращающие Unit пишутся со знаком равенства

def printValue(x: String): Unit = 
  println("I ate a %s".format(x))

или эквивалентно (с выводом типа и опусканием ненужной новой строки):

def printValue(x: String) = println("I ate a %s" format x)

Вывод типа

Из-за вывода типа тип переменных, возвращаемые значения функции и многие другие выражения обычно могут быть опущены, поскольку компилятор может их определить. Примеры: val x = "foo" (для неизменяемой константы или неизменяемого объекта ) или var x = 1.5 (для переменной, значение которой впоследствии можно изменить). Вывод типа в Scala по существу является локальным, в отличие от более глобального алгоритма Хиндли-Милнера , используемого в Haskell , ML и других более чисто функциональных языках. Это сделано для облегчения объектно-ориентированного программирования. В результате некоторые типы по-прежнему необходимо объявлять (в первую очередь, параметры функций и типы возвращаемых рекурсивных функций ), например

def formatApples(x: Int) = "I ate %d apples".format(x)

или (с типом возвращаемого значения, объявленным для рекурсивной функции)

def factorial(x: Int): Int =
  if x == 0 then 1
  else x * factorial(x - 1)

Анонимные функции

существует удобный синтаксис В Scala функции являются объектами, и для указания анонимных функций . Примером может служить выражение x => x < 2, который определяет функцию с одним параметром, которая сравнивает свой аргумент, чтобы убедиться, что он меньше 2. Это эквивалентно форме Lisp (lambda (x) (< x 2)). Обратите внимание, что ни тип x ни тип возвращаемого значения не требуется явно указывать, и его обычно можно определить путем вывода типа ; но они могут быть указаны явно, например, как (x: Int) => x < 2 или даже (x: Int) => (x < 2): Boolean.

Анонимные функции ведут себя как настоящие замыкания , поскольку они автоматически захватывают любые переменные, которые лексически доступны в среде включающей функции. Эти переменные будут доступны даже после завершения работы включающей функции, и, в отличие от анонимных внутренних классов Java , их не нужно объявлять как окончательные. (Такие переменные можно даже изменить, если они изменяемы, и измененное значение будет доступно при следующем вызове анонимной функции.)

Еще более короткая форма анонимной функции использует переменные- заполнители : например, следующее:

list map { x => sqrt(x) }

можно записать более кратко как

list map { sqrt(_) }

или даже

list map sqrt

Неизменяемость

Scala проводит различие между неизменяемыми и изменяемыми переменными. Изменяемые переменные объявляются с использованием var Ключевое слово и неизменяемые значения объявляются с использованием val ключевое слово. Переменная, объявленная с использованием val Ключевое слово нельзя переназначить так же, как переменную, объявленную с помощью final Ключевое слово не может быть переназначено в Java. vals лишь поверхностно неизменяемы, то есть объект, на который ссылается val, не гарантирует, что он сам по себе будет неизменяемым.

Однако неизменяемые классы поощряются по соглашению, и стандартная библиотека Scala предоставляет богатый набор неизменяемых классов- коллекций . Scala предоставляет изменяемые и неизменяемые варианты большинства классов коллекций, и неизменяемая версия используется всегда, если изменяемая версия не импортируется явно. Неизменяемые варианты — это постоянные структуры данных , которые всегда возвращают обновленную копию старого объекта вместо разрушительного обновления старого объекта на месте. Примером этого являются неизменяемые связанные списки , в которых добавление элемента в список осуществляется путем возврата нового узла списка, состоящего из элемента и ссылки на хвост списка. Добавление элемента в список можно выполнить только путем добавления всех элементов старого списка в новый список, содержащий только новый элемент. Точно так же вставка элемента в середину списка скопирует первую половину списка, но сохранит ссылку на вторую половину списка. Это называется структурным разделением. Это обеспечивает очень простой параллелизм — никаких блокировок не требуется, поскольку общие объекты никогда не изменяются.

Ленивая (нестрогая) оценка

По умолчанию оценка строгая («нетерпеливая»). Другими словами, Scala оценивает выражения, как только они становятся доступными, а не по мере необходимости. Однако можно объявить переменную нестрогой («ленивой») с помощью lazy Ключевое слово, означающее, что код для создания значения переменной не будет оцениваться до тех пор, пока на переменную не будет сделана первая ссылка. Также существуют нестрогие коллекции различных типов (например, типа Stream, нестрогий связанный список), и любую коллекцию можно сделать нестрогой с помощью view метод. Нестрогие коллекции обеспечивают хорошее семантическое соответствие таким вещам, как данные, создаваемые сервером, где оценка кода для создания последующих элементов списка (что, в свою очередь, запускает запрос на сервер, возможно, расположенный где-то еще в Интернете) только происходит, когда элементы действительно необходимы.

Хвостовая рекурсия

Языки функционального программирования обычно обеспечивают оптимизацию хвостовых вызовов , позволяющую широко использовать рекурсию без проблем переполнения стека . Ограничения в байт-коде Java усложняют оптимизацию хвостовых вызовов в JVM. В общем, функция, вызывающая сама себя хвостовым вызовом, может быть оптимизирована, а взаимно рекурсивные функции — нет. батуты . В качестве обходного пути были предложены Поддержка батута реализована библиотекой Scala с объектом scala.util.control.TailCalls начиная с Scala 2.8.0 (выпущенной 14 июля 2010 г.). Функция может быть дополнительно аннотирована с помощью @tailrec, и в этом случае он не будет скомпилирован, если он не является хвостовой рекурсией.

Пример этой оптимизации может быть реализован с использованием определения факториала . Например, рекурсивная версия факториала:

def factorial(n: Int): Int =
  if n == 0 then 1
  else n * factorial(n - 1)

Можно оптимизировать для хвостовой рекурсивной версии следующим образом:

@tailrec
def factorial(n: Int, accum: Int): Int = 
  if n == 0 then accum
  else factorial(n - 1, n * accum)

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

def factorial(n: Int): Int = 

  @tailrec
  def loop(current: Int, accum: Int): Int = 
  
    if n == 0 then accum
    else loop(current - 1, n * accum)
  
  loop(n, 1) // Call to the closure using the base case
  
end factorial

Это обеспечивает оптимизацию хвостового вызова и, таким образом, предотвращает ошибку переполнения стека.

Классы случаев и сопоставление с образцом

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

Пример определения алгоритма быстрой сортировки с использованием сопоставления с образцом:

def qsort(list: List[Int]): List[Int] = list match 
  case Nil => Nil
  case pivot :: tail =>
    val (smaller, rest) = tail.partition(_ < pivot)
    qsort(smaller) ::: pivot :: qsort(rest)

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

The match Оператор используется для сопоставления с образцом объекта, хранящегося в list. Каждый case выражение по очереди проверяется, будет ли оно совпадать, и первое совпадение определяет результат. В этом случае, Nil соответствует только буквальному объекту Nil, но pivot :: tail соответствует непустому списку и одновременно деструктурирует список в соответствии с заданным шаблоном. В этом случае связанный код будет иметь доступ к локальной переменной с именем pivot удерживая заголовок списка и еще одну переменную tail держа хвост списка. Обратите внимание, что эти переменные доступны только для чтения и семантически очень похожи на привязки переменных , установленные с помощью let оператор в Lisp и Scheme.

Сопоставление с образцом также происходит в объявлениях локальных переменных. В этом случае возвращаемое значение вызова tail.partition представляет собой кортеж — в данном случае два списка. (Кортежи отличаются от других типов контейнеров, например списков, тем, что они всегда имеют фиксированный размер, а элементы могут быть разных типов — хотя здесь они оба одинаковы.) Сопоставление с образцом — это самый простой способ получить две части кортеж.

Форма _ < pivot — объявление анонимной функции с переменной-заполнителем; см. раздел выше об анонимных функциях.

Операторы списка :: (который добавляет элемент в начало списка, аналогично cons в Lisp и Scheme) и ::: (который объединяет два списка вместе, аналогично append в Lisp и Scheme) оба появляются. Несмотря на внешний вид, ни в одном из этих операторов нет ничего «встроенного». Как указано выше, любая строка символов может служить именем функции, а метод, применяемый к объекту, может быть записан в «инфиксном» стиле без точки и круглых скобок. Строка выше, как написано:

qsort(smaller) ::: pivot :: qsort(rest)

также можно было бы записать так:

qsort(rest).::(pivot).:::(qsort(smaller))

в более стандартной записи вызова метода. (Методы, заканчивающиеся двоеточием, являются правоассоциативными и привязываются к объекту справа.)

Частичные функции

В приведенном выше примере сопоставления с образцом тело match Оператор представляет собой частичную функцию , которая состоит из ряда case выражения, причем преобладает первое соответствующее выражение, аналогично телу оператора переключения . Частичные функции также используются в части обработки исключений. try заявление:

try 
  ...
catch 
  case nfe: NumberFormatException => { println(nfe); List(0) }
  case _ => Nil

Наконец, частичную функцию можно использовать отдельно, и результат ее вызова эквивалентен выполнению match над ним. Например, предыдущий код быстрой сортировки можно записать так:

val qsort: List[Int] => List[Int] = 
  case Nil => Nil
  case pivot :: tail =>
    val (smaller, rest) = tail.partition(_ < pivot)
    qsort(smaller) ::: pivot :: qsort(rest)

Здесь объявляется доступная только для чтения переменная , тип которой является функцией от списков целых чисел к спискам целых чисел, и привязывается к частичной функции. (Обратите внимание, что единственный параметр частичной функции никогда не объявляется и не именуется явно.) Однако мы все равно можем вызывать эту переменную точно так же, как если бы это была обычная функция:

scala> qsort(List(6,2,5,9))
res32: List[Int] = List(2, 5, 6, 9)

Объектно-ориентированные расширения

Scala — чистый объектно-ориентированный язык в том смысле, что каждое значение является объектом . Типы данных и поведение объектов описываются классами и признаками . Абстракции классов расширяются за счет создания подклассов и гибкого механизма композиции на основе миксинов , позволяющего избежать проблем множественного наследования .

Java в Scala Traits — это замена интерфейсов . Интерфейсы в версиях Java до 8 сильно ограничены и могут содержать только объявления абстрактных функций. Это привело к критике за то, что предоставление удобных методов в интерфейсах неудобно (одни и те же методы должны быть переопределены в каждой реализации), а расширение опубликованного интерфейса обратно совместимым способом невозможно. Трейты похожи на классы- миксины в том, что они обладают почти всеми возможностями обычного абстрактного класса, у них отсутствуют только параметры класса (эквивалент параметров конструктора в Scala), поскольку трейты всегда смешиваются с классом. super Оператор ведет себя особым образом в типажах, позволяя объединять признаки с помощью композиции в дополнение к наследованию. Следующий пример представляет собой простую оконную систему:

abstract class Window:
  // abstract
  def draw()


class SimpleWindow extends Window:
  def draw() 
    println("in SimpleWindow")
    // draw a basic window
  

trait WindowDecoration extends Window


trait HorizontalScrollbarDecoration extends WindowDecoration:
  // "abstract override" is needed here for "super()" to work because the parent
  // function is abstract. If it were concrete, regular "override" would be enough.
  abstract override def draw() 
    println("in HorizontalScrollbarDecoration")
    super.draw()
    // now draw a horizontal scrollbar
  

trait VerticalScrollbarDecoration extends WindowDecoration:
  abstract override def draw() 
    println("in VerticalScrollbarDecoration")
    super.draw()
    // now draw a vertical scrollbar
  

trait TitleDecoration extends WindowDecoration:
  abstract override def draw() 
    println("in TitleDecoration")
    super.draw()
    // now draw the title bar

Переменную можно объявить следующим образом:

val mywin = new SimpleWindow with VerticalScrollbarDecoration with HorizontalScrollbarDecoration with TitleDecoration

Результат звонка mywin.draw() является:

in TitleDecoration
in HorizontalScrollbarDecoration
in VerticalScrollbarDecoration
in SimpleWindow

Другими словами, вызов draw сначала выполнил код в TitleDecoration (примешивается последняя черта), затем (через super() вызовы) передаются обратно через другие смешанные свойства и, в конечном итоге, в код Window, хотя ни одна из черт не унаследована друг от друга . Это похоже на шаблон декоратора , но более лаконично и менее подвержено ошибкам, поскольку не требует явной инкапсуляции родительского окна, явной пересылки функций, реализация которых не изменяется, или использования инициализации отношений сущностей во время выполнения. . В других языках аналогичный эффект может быть достигнут во время компиляции с помощью длинной линейной цепочки наследования реализации , но с недостатком по сравнению со Scala, заключающимся в том, что для каждой возможной комбинации примесей придется объявлять одну линейную цепочку наследования.

Выразительная система шрифтов

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

• Классы и абстрактные типы как члены объектов
• Структурные типы
• Типы, зависящие от пути
• Сложные типы
• Явно типизированные ссылки на себя
• Общие классы
• Полиморфные методы
• Верхние и нижние границы типа
• Дисперсия
• Аннотация
• Просмотры

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

Тип обогащения

Распространенный метод в Scala, известный как «обогатить мою библиотеку». (первоначально « Прокачай мою библиотеку »; в 2006 году Мартин Одерски назвал его по поводу этой формулировки были высказаны опасения из-за ее негативного подтекста. и незрелость ), позволяет использовать новые методы, как если бы они были добавлены к существующим типам. Это похоже на концепцию методов расширения C# , но более мощная, поскольку этот метод не ограничивается добавлением методов и может, например, использоваться для реализации новых интерфейсов. В Scala этот метод включает объявление неявного преобразования типа, «получающего» метод, в новый тип (обычно класс), который оборачивает исходный тип и предоставляет дополнительный метод. Если метод не может быть найден для данного типа, компилятор автоматически ищет любые применимые неявные преобразования к типам, которые предоставляют рассматриваемый метод.

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

В следующем примере показано обогащение типа Int с методами isEven и isOdd:

object MyExtensions:
  extension (i: Int)
    def isEven = i % 2 == 0
    def isOdd  = !isEven
 

import MyExtensions._  // bring implicit enrichment into scope
4.isEven  // -> true

Импорт членов MyExtensions приводит к неявному преобразованию в класс расширения IntPredicates в объем.

Параллелизм

Стандартная библиотека Scala включает поддержку фьючерсов и промисов в дополнение к стандартным API параллелизма Java. Первоначально в него также была включена поддержка модели актора , которая теперь доступна как отдельный исходный код платформы Akka. лицензируется Lightbend Inc. Акторы Akka могут распространяться или комбинироваться с программной транзакционной памятью ( транзакторы ). Альтернативными реализациями последовательных процессов связи (CSP) для передачи сообщений на основе каналов являются Communicating Scala Objects, или просто через JCSP .

Актер подобен экземпляру потока с почтовым ящиком. Его можно создать system.actorOf, переопределяя receive метод получения сообщений и использование ! (восклицательный знак) метод отправки сообщения. В следующем примере показан EchoServer, который может получать сообщения, а затем распечатывать их.

val echoServer = actor(new Act:
  become:
    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 returns parallel implementation of a collection
println("time: " + (System.currentTimeMillis - t) + "ms")

Помимо фьючерсов и обещаний, поддержки актеров и параллелизма данных , Scala также поддерживает асинхронное программирование с программной транзакционной памятью и потоками событий.

Кластерные вычисления

Самым известным решением для кластерных вычислений с открытым исходным кодом, написанным на Scala, является Apache Spark . Кроме того, на Scala написана Apache Kafka , публикации и подписки, очередь сообщений популярная в Spark и других технологиях потоковой обработки.

Тестирование

Есть несколько способов тестирования кода в Scala. ScalaTest поддерживает несколько стилей тестирования и может интегрироваться со средами тестирования на основе Java. ScalaCheck — это библиотека, похожая на QuickCheck в Haskell . specs2 — это библиотека для написания спецификаций исполняемого программного обеспечения. ScalaMock обеспечивает поддержку тестирования функций высокого порядка и каррированных функций. JUnit и TestNG — популярные среды тестирования, написанные на Java.

Версии

Версия	Выпущенный	Функции
1.0.0-b2	8 декабря 2003 г.	—
1.1.0-b1	19 февраля 2004 г.	scala.Перечисление Лицензия Scala была заменена на пересмотренную лицензию BSD.
1.1.1	23 марта 2004 г.	Поддержка статических внутренних классов Java. Улучшения классов библиотеки для Iterable, Array, xml.Elem, Buffer
1.2.0	9 июня 2004 г.	Просмотры Литералы XML (будут «отброшены в ближайшем будущем и заменены интерполяцией строк XML» )
1.3.0	16 сентября 2004 г.	Поддержка Microsoft .NET Закрытие метода Синтаксис типов для методов без параметров изменен с [] T к => T
1.4.0	20 июня 2005 г.	Атрибуты match ключевое слово заменяет match метод Экспериментальная поддержка типов среды выполнения
2.0	12 марта 2006 г.	Компилятор полностью переписан на Scala. Экспериментальная поддержка дженериков Java implicit и requires ключевые слова match ключевое слово разрешено только инфиксным оператором with соединение допускается только после extends пункт Новые строки могут использоваться в качестве разделителей операторов вместо точек с запятой. Шаблоны соответствия регулярных выражений ограничены только шаблонами последовательностей. For-comprehension допускает определения значений и шаблонов. Параметры класса могут иметь префикс val или var. Частная видимость имеет квалификаторы
2.1.0	17 марта 2006 г.	инструмент sbaz, интегрированный в дистрибутив Scala match ключевое слово заменяет match метод Экспериментальная поддержка типов среды выполнения
2.1.8	23 августа 2006 г.	Защищенная видимость имеет квалификаторы На частные члены класса можно ссылаться из сопутствующего модуля класса и наоборот. Обобщенный неявный поиск Соответствие типизированному шаблону ужесточено для одноэлементных типов.
2.3.0	23 ноября 2006 г.	Функции, возвращающие Unit не нужно явно указывать тип возвращаемого значения Переменные типа и типы различаются при сопоставлении с образцом. All и AllRef переименован в Nothing и Null
2.4.0	9 марта 2007 г.	private и protected модификаторы принимают [this] квалификатор Кортежи можно записать с помощью круглых скобок. Первичный конструктор класса теперь может быть помечен как частный или защищенный. Атрибуты заменены аннотациями с новым синтаксисом. Собственные псевдонимы Операторы можно комбинировать с присваиванием
2.5.0	2 мая 2007 г.	Параметры типа и члены абстрактного типа также могут абстрагироваться от конструкторов типов. Поля объекта могут быть инициализированы до вызова родительских конструкторов. Изменение синтаксиса для понимания Неявные анонимные функции (с подчеркиванием параметров) Сопоставление шаблонов анонимных функций расширено для поддержки любого искусства.
2.6.0	27 июля 2007 г.	Экзистенциальные типы Ленивые значения Структурные типы
2.7.0	7 февраля 2008 г.	Универсальные типы Java, поддерживаемые по умолчанию Расширен функционал кейс-классов
2.8.0	14 июля 2010 г.	Пересмотреть общую, унифицированную и всеобъемлющую структуру для типов коллекций. Тип специализации Именованные аргументы и аргументы по умолчанию Объекты пакета Улучшенные аннотации
2.9.0	12 мая 2011 г.	Параллельные коллекции Потокобезопасный App черта заменяет Application черта DelayedInit черта Улучшения взаимодействия с Java
2.10	4 января 2013 г.	Классы значений Неявные классы Строковая интерполяция Фьючерсы и обещания Динамический и применитьDynamic Зависимые типы методов: def identity(x: AnyRef): x.type = x // the return type says we return exactly what we got Новый эмиттер байт-кода на основе ASM: Может быть нацелен на JDK 1.5, 1.6 и 1.7. По умолчанию генерирует байт-код 1,6. Старый бэкэнд версии 1.5 устарел. Новое средство сопоставления с образцом: переписано с нуля для создания более надежного кода (больше никаких экспоненциальных раздутий). генерация кода и анализ теперь независимы (последний можно отключить с помощью -Xno-patmat-analysis) Улучшения Скаладока Неявные значения (флаг -implicits) Диаграммы (флаг -diagrams, требуется графвиз) Группы (-группы) Модульные возможности языка Параллельные коллекции теперь настраиваются с помощью пользовательских пулов потоков Что актеры теперь являются частью распределения scala.actors устарела, и реализация akka теперь включена в дистрибутив. Улучшения производительности Более быстрые вкладыши Сумма диапазона# теперь равна O(1) Обновление библиотеки ForkJoin. Исправления в неизменяемом TreeSet/TreeMap. Улучшения в частичных функциях Добавление ??? и NotImplementedError Добавление классов типов IsTraversableOnce + IsTraversableLike для методов расширения. Устаревания и очистка Устаревший синтаксис чисел с плавающей запятой и восьмеричных литералов Удален scala.dbc. Экспериментальные возможности Скала-отражение Макросы
2.10.2	6 июня 2013 г.	—
2.10.3	1 октября 2013 г.	—
2.10.4	18 марта 2014 г.	—
2.10.5	5 марта 2015 г.	—
2.11.0	21 апреля 2014 г.	Улучшения производительности коллекции Улучшения производительности компилятора
2.11.1	20 мая 2014 г.	—
2.11.2	22 июля 2014 г.	—
2.11.4	31 октября 2014 г.	—
2.11.5	8 января 2015 г.	—
2.11.6	5 марта 2015 г.	—
2.11.7	23 июня 2015 г.	—
2.11.8	8 марта 2016 г.	—
2.11.11	18 апреля 2017 г.	—
2.11.12	13 ноября 2017 г.	—
2.12.0	3 ноября 2016 г.	Требуется Java 8 Сгенерирован байт-код Java 8 Java 8 SAM ( функциональный интерфейс ) Поддержка языка
2.12.1	5 декабря 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	4 декабря 2018 г.	Первый выпуск Scala 2.12 с измененной лицензией на Apache v2.0.
2.12.9	5 августа 2019 г.	—
2.12.10	10 сентября 2019 г.	—
2.12.11	16 марта 2020 г.	—
2.12.12	13 июля 2020 г.	—
2.12.13	12 января 2021 г.	—
2.12.14	28 мая 2021 г.	—
2.12.15	14 сен 2021 г.	—
2.12.16	10 июня 2022 г.	—
2.12.17	16 сентября 2022 г.	—
2.12.18	7 июня 2023 г.	—
2.12.19	25 февраля 2024 г.	—
2.13.0	11 июня 2019 г.	Переработана стандартная библиотека коллекций. Литеральные типы Частичная унификация типов Неявное имя Оптимизация компилятора
2.13.1	18 сентября 2019 г.	—
2.13.2	22 апреля 2020 г.	—
2.13.3	25 июня 2020 г.	—
2.13.4	19 ноября 2020 г.	—
2.13.5	22 февраля 2021 г.	—
2.13.6	17 мая 2021 г.	—
2.13.7	1 ноября 2021 г.	—
2.13.8	12 января 2022 г.	—
2.13.9	21 сентября 2022 г.	—
2.13.10	13 октября 2022 г.	—
2.13.11	7 июня 2023 г.	—
2.13.12	11 сентября 2023 г.	—
2.13.13	26 февраля 2024 г.	—
2.13.14	1 мая 2024 г.	—
3.0.0	13 мая 2021 г.	—
3.0.1	31 июля 2021 г.	—
3.0.2	7 сентября 2021 г.	—
3.1.0	21 октября 2021 г.	—
3.1.1	1 февраля 2022 г.	—
3.1.2	12 апреля 2022 г.	—
3.1.3	21 июня 2022 г.	—
3.2.0	5 сентября 2022 г.	—
3.2.1	7 ноября 2022 г.	—
3.2.2	30 января 2023 г.	—
3.3.0	30 мая 2023 г.	—
3.3.1	7 сентября 2023 г.	—
3.3.2	29 февраля 2024 г.	—
3.3.3	29 февраля 2024 г.	—
3.4.0	29 февраля 2024 г.	—
3.4.1	29 марта 2024 г.	—
3.4.2	16 мая 2024 г.	—

Сравнение с другими языками JVM

Scala часто сравнивают с Groovy и Clojure , двумя другими языками программирования, также использующими JVM. Существенные различия между этими языками существуют в системе типов, в степени поддержки каждым языком объектно-ориентированного и функционального программирования, а также в сходстве их синтаксиса с синтаксисом Java.

Scala типизирован статически , тогда как Groovy и Clojure типизированы динамически . Это делает систему типов более сложной и трудной для понимания, но позволяет практически все ошибки типа должны быть обнаружены во время компиляции и могут привести к значительному ускорению выполнения. Напротив, динамическая типизация требует большего тестирования для обеспечения корректности программы и, следовательно, обычно медленнее, что обеспечивает большую гибкость и простоту программирования. Что касается различий в скорости, текущие версии Groovy и Clojure допускают дополнительные аннотации типов, чтобы помочь программам избежать накладных расходов на динамическую типизацию в тех случаях, когда типы практически статичны. Эти накладные расходы еще больше сокращаются при использовании последних версий JVM, которые были расширены за счет динамической инструкции вызова для методов, определенных с динамически типизированными аргументами. Эти достижения сокращают разрыв в скорости между статической и динамической типизацией, хотя статически типизированный язык, такой как Scala, по-прежнему является предпочтительным выбором, когда эффективность выполнения очень важна.

Что касается парадигм программирования, Scala наследует объектно-ориентированную модель Java и расширяет ее различными способами. Несмотря на то, что Groovy также сильно объектно-ориентирован, он больше ориентирован на снижение многословия. В Clojure объектно-ориентированному программированию уделяется меньше внимания, а функциональное программирование является основной сильной стороной языка. Scala также имеет множество средств функционального программирования, включая функции, имеющиеся в продвинутых функциональных языках, таких как Haskell , и пытается быть независимым между двумя парадигмами, позволяя разработчику выбирать между двумя парадигмами или, что чаще, некоторой их комбинацией.

Что касается сходства синтаксиса с Java, Scala наследует большую часть синтаксиса Java, как и в случае с Groovy. Clojure, с другой стороны, следует синтаксису Lisp , который отличается как по внешнему виду, так и по философии.

Принятие

Языковые рейтинги

Еще в 2013 году, когда Scala была в версии 2.10, Технологический радар ThoughtWorks , представляющий собой основанный на мнениях двухгодичный отчет группы старших технологов, рекомендовал использовать Scala в своей категории языков и фреймворков.

В июле 2014 года эта оценка стала более конкретной и теперь относится к «Scala, хорошие части», которая описывается так: «Чтобы успешно использовать Scala, вам необходимо изучить язык и иметь очень твердое мнение о том, какие части являются правильными». для вас, создающих собственное определение Scala, хорошие стороны».

В обзоре Java за 2018 год состояния который собрал данные от 5160 разработчиков по различным темам, связанным с Java, Scala занимает третье место по использованию альтернативных языков на JVM . По сравнению с предыдущим годом опроса, использование Scala среди альтернативных языков JVM упало с 28,4% до 21,5%, обогнав Kotlin , доля которого выросла с 11,4% в 2017 году до 28,8% в 2018 году. Индекс популярности языков программирования, который отслеживает поиск учебных пособий по языку, занял Scala 15-е место в апреле 2018 года с небольшой тенденцией к снижению и 17-е место в январе 2021 года. Это делает Scala третьим по популярности языком на основе JVM после Java и Kotlin , занявших 12-е место.

Рейтинг языков программирования RedMonk , который составляет рейтинг на основе количества проектов GitHub и вопросов, заданных на Stack Overflow , в январе 2021 года поставил Scala на 14-е место. Scala был помещен в группу языков второго уровня — впереди Go , PowerShell и Haskell и позади Swift , Objective-C , Typescript и R. Здесь

Индекс ТИОБЕ Для определения популярности языка программирования используются рейтинги поисковых систем в Интернете и аналогичный подсчет публикаций для определения популярности языка. В сентябре 2021 года он показал Scala на 31-м месте. В этом рейтинге Scala опередила Haskell (38-е место) и Erlang , но уступила Go (14-е место), Swift (15-е место) и Perl (19-е место).

По состоянию на 2022 год Языки на основе JVM, такие как Clojure, Groovy и Scala, имеют высокие рейтинги, но все же значительно менее популярны, чем исходный язык Java , который обычно занимает три первых места.

Компании

• В апреле 2009 года Twitter объявил, что перевел большую часть своей серверной части с Ruby на Scala и намерен преобразовать остальную часть.
• Tesla, Inc. использует Akka со Scala в серверной части виртуальной электростанции Tesla. Таким образом, модель Actor используется для представления и управления устройствами, которые вместе с другими компонентами составляют экземпляр виртуальной электростанции, а Reactive Streams используются для сбора и обработки данных.
• Apache Kafka реализован в Scala в отношении большей части своего ядра и других важных частей. Он поддерживается и расширяется посредством проекта с открытым исходным кодом и компанией Confluent.
• Gilt использует Scala и Play Framework .
• Foursquare использует Scala и Lift .
• Coursera использует Scala и Play Framework .

• Apple Inc. использует Scala в некоторых командах наряду с Java и платформой Play.
• The Guardian. с высокой посещаемостью газеты Веб-сайт Guardian.co.uk объявила в апреле 2011 года о переходе с Java на Scala.
• В 2014 году газета New York Times сообщила, что ее внутренняя система управления контентом Blackbeard построена с использованием Scala, Akka и Play.
• Газета Huffington Post начала использовать Scala как часть своей системы доставки контента Athena в 2013 году.
• Швейцарский банк UBS одобрил Scala для общего производственного использования.
• LinkedIn использует Scalatra микрофреймворк для реализации своего Signal API.
• Meetup использует набор инструментов Unfiltered для API реального времени.
• Помните, что Milk использует набор инструментов Unfiltered, Scala и Akka для общедоступного API и обновлений в реальном времени.
• Verizon стремится создать «фреймворк следующего поколения» с использованием Scala.
• Airbnb разрабатывает программное обеспечение для машинного обучения с открытым исходным кодом Aerosolve, написанное на Java и Scala.
• Zalando перенесла свой технологический стек с Java на Scala и Play.
• SoundCloud использует Scala для своей серверной части, применяя такие технологии, как Finagle (микросервисы), Ошпаривание и искра (обработка данных).
• Databricks использует Scala для платформы больших данных Apache Spark .
• Morgan Stanley широко использует Scala в своих проектах, связанных с финансами и активами.
• есть команды В Google и Alphabet Inc. , которые используют Scala, в основном благодаря приобретениям, таким как Firebase. и Гнездо.
• Walmart Canada использует Scala в качестве внутренней платформы.
• Duolingo использует Scala для своего внутреннего модуля, генерирующего уроки.
• HMRC использует Scala для многих налоговых заявок правительства Великобритании.
• M1 Finance использует Scala в качестве внутренней платформы.

Критика

В ноябре 2011 года Yammer отошла от Scala по причинам, включающим кривую обучения новых членов команды и несовместимость одной версии компилятора Scala с другой. В марте 2015 года бывший вице-президент группы разработки платформ в Twitter Раффи Крикорян заявил, что не выбрал бы Scala в 2011 году из-за ее кривой обучения . В том же месяце LinkedIn старший вице-президент Кевин Скотт заявил о своем решении «минимизировать [свою] зависимость от Scala».

См. также

• sbt — широко используемый инструмент сборки проектов Scala.
• Spark Framework предназначен для обработки больших данных и поддерживает исключительно Scala.
• Neo4j — это среда Java Spring, поддерживаемая Scala, с функциональностью, зависящей от предметной области, аналитическими возможностями, графовыми алгоритмами и многим другим.
• Играть! , платформа веб-приложений с открытым исходным кодом, поддерживающая Scala.
• Akka — набор инструментов с открытым исходным кодом для создания параллельных и распределенных приложений.
• Chisel — язык с открытым исходным кодом, созданный на основе Scala и используемый для проектирования и создания аппаратного обеспечения.

См. Также: Категория: Бесплатное программное обеспечение, написанное на Scala.

Дальнейшее чтение

• Одерский, Мартин; Ложка, Лекс; Веннерс, Билл (15 декабря 2019 г.). Программирование на Scala: подробное пошаговое руководство (4-е изд.). Артима Инк . п. 896. ИСБН  978-0-9815316-1-8 .
• Хорстманн, Кей (15 декабря 2016 г.). Скала для нетерпеливых (2-е изд.). Аддисон-Уэсли Профессионал . п. 384. ИСБН  978-0-134-54056-6 .
• Уэмплер, Дин; Пейн, Алекс (14 декабря 2014 г.). Программирование на Scala: масштабируемость = функциональное программирование + объекты (2-е изд.). О'Рейли Медиа . п. 583. ИСБН  978-1-491-94985-6 .
• Суэрет, Джошуа Д. (весна 2011 г.). Скала в глубине . Публикации Мэннинга . п. 225 . ISBN  978-1-935182-70-2 .
• Мередит, Грегори (2011). Монадические шаблоны проектирования для Интернета (PDF) (1-е изд.). п. 300.
• Одерский, Мартин; Ложка, Лекс; Веннерс, Билл (10 декабря 2008 г.). Программирование на Scala, электронная книга (1-е изд.). Артима Инк .