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

Язык программирования общего назначения

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

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

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

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

История

Разработка Scala началась в 2001 году в Федеральной политехнической школе Лозанны (EPFL) (в Лозанне , Швейцария ) Мартином Одерски . Он стал продолжением работы над Funnel, языком программирования, сочетающим в себе идеи функционального программирования и сетей Петри . ^[14] Одерски ранее работал над Generic Java и javac , компилятором Java компании Sun. ^[14]

После внутреннего выпуска в конце 2003 года Scala был выпущен публично в начале 2004 года на платформе Java . ^{[15] [7] [14] [16]} Вторая версия (v2.0) последовала в марте 2006 года ^.

17 января 2011 года команда Scala выиграла пятилетний исследовательский грант в размере более 2,3 миллиона евро от Европейского исследовательского совета . ^[17] 12 мая 2011 года Одерский и его коллеги основали Typesafe Inc. (позже переименованную в Lightbend Inc. ), компанию, которая занимается предоставлением коммерческой поддержки, обучения и услуг для Scala. В 2011 году Typesafe получила инвестиции в размере 3 миллионов долларов от Greylock Partners . ^{[18] [19] [20] [21]}

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

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

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

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

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

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

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

Примеры

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

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

@main def main () = println ( «Привет, мир!» )    

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

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

$ scalac HelloWorld.scala

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

$ скала HelloWorld

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

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

println ( «Привет, мир!» )

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

$ scala HelloWorld2.scala

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

$ scala -e 'println("Привет, мир!")'

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

$ scala Добро пожаловать в Scala 2.12.2 (64-битная серверная виртуальная машина Java HotSpot(TM), Java 1.8.0_131). Введите выражения для оценки. Или попробуйте :help.scala> List(1, 2, 3).map(x => x * x) res0: List[Int] = List(1, 4, 9)скала>

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

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

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

• Scala не требует точки с запятой (;) для завершения операторов.
• Типы значений пишутся с заглавной буквы (регистр предложения): Int, Double, Booleanвместо int, double, boolean.
• Типы параметров и возвращаемых значений следуют, как в Pascal , а не предшествуют, как в C.
• Перед методами должен стоять def.
• Локальным переменным или переменным класса должно предшествовать val(указывает на неизменяемую переменную) или var(указывает на изменяемую переменную).
• Оператор returnв функции не нужен (хотя и разрешен); значение последнего выполненного оператора или выражения обычно является значением функции.
• Вместо оператора приведения Java (Type) fooScala использует 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 и Scala:

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

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

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

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

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 .
• Scala различает методы без скобок ( 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
• При вызове методов допускается использование фигурных скобок вместо круглых. Это позволяет реализовать чисто библиотечные реализации новых структур управления. ^[31] Например, 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). Это означает, что в Scala нет различия между примитивными типами и коробочными типами (например, intпротив ). упаковка и распаковка полностью прозрачны для пользователя. Scala 2.10 позволяет пользователю определять новые типы значений.Integer

For-выражения

Вместо циклов Java foreach для обхода итератора в Scala есть for-выражения, которые похожи на генераторы списков в таких языках, как Haskell, или комбинацию генераторов списков и выражений в Python . Выражения For с использованием yieldключевого слова позволяют создать новую коллекцию путем итерации по существующей, возвращая новую коллекцию того же типа. Они преобразуются компилятором в последовательность map, flatMapи filterвызываются. Там , где yieldон не используется, код приближается к императивному циклу путем перевода в foreach.

Простой пример:

val s = for ( x <- от 1 до 25 , если x * x > 50 ) выход 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 как метод расширения целых чисел с использованием метода, известного как неявные преобразования ^[32] , который позволяет добавлять новые методы к существующим типам.)

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

// Учитывая карту, на которой указаны пользователи Твиттера, упомянутые в наборе твитов, // и количество упоминаний каждого пользователя, найдите пользователей // на карте известных политиков и верните новую карту, показывающую только // Демократическую партию. политики (как объекты, а не строки). val dem_mentions = for ( упоминание , раз ) <- упоминает аккаунт < -accounts . получить ( упомянуть ) если аккаунт . партия == "Демократическая" доходность ( счет , раз )                  

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

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

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

Примеры:

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

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

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

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

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

Чтобы было понятно, что все функции являются выражениями, даже возвращающие методы 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 яблок" . формат ( х )    

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

def факториал ( x : Int ): Int = если x == 0 , то 1 иначе x * факториал ( 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 предоставляет изменяемые и неизменяемые варианты большинства классов коллекций, и неизменяемая версия используется всегда, если изменяемая версия не импортируется явно. ^[34] Неизменяемые варианты — это постоянные структуры данных , которые всегда возвращают обновленную копию старого объекта вместо разрушительного обновления старого объекта на месте. Примером этого являются неизменяемые связанные списки , в которых добавление элемента в список осуществляется путем возврата нового узла списка, состоящего из элемента и ссылки на хвост списка. Добавление элемента в список можно выполнить только путем добавления всех элементов старого списка в новый список, содержащий только новый элемент. Точно так же вставка элемента в середину списка скопирует первую половину списка, но сохранит ссылку на вторую половину списка. Это называется структурным разделением. Это обеспечивает очень простой параллелизм — никаких блокировок не требуется, поскольку общие объекты никогда не изменяются. ^[35]

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

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

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

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

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

def факториал ( n : Int ): Int = если n == 0 , то 1 иначе n * факториал ( n - 1 )                

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

@tailrec def факториал ( n : Int , accum : Int ): Int = если n == 0 , то накапливается иначе факториал ( n - 1 , n * accum )                    

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

def факториал ( n : Int ): Int =      @tailrec цикл def ( текущий : Int , накопленный : Int ): Int =         если n == 0 , то накапливать      цикл else ( текущий - 1 , n * накопление )        цикл ( n , 1 ) // Вызов замыкания с использованием базового случая   конечный факториал 

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

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

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

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

def qsort ( list : List [ Int ]): List [ Int ] = список совпадений регистр Nil => Nil case пивот :: хвост => val ( меньше , отдых ) = хвост . раздел ( _ < центр ) qsort ( меньше ) ::: центр :: qsort ( отдых )                            

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

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

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

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

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

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

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

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

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

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

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

попробуйте ... поймать случай nfe : NumberFormatException => { println ( nfe ); Список ( 0 ) } case _ => Nil               

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

val qsort : List [ Int ] => List [ Int ] = case Nil => Nil case Pivot :: Tail => val ( меньше , остальное ) = Tail . раздел ( _ < центр ) qsort ( меньше ) ::: центр :: qsort ( отдых )                           

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

scala > qsort ( Список ( 6 , 2 , 5 , 9 )) res32 : Список [ Int ] = Список ( 2 , 5 , 6 , 9 )       

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

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

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

абстрактный класс Window : // абстрактное определение ( )     класс SimpleWindow расширяет окно : def draw () println ( "in SimpleWindow" ) // рисуем базовое окно         черта WindowDecoration расширяет окно   типаж HorizontalScrollbarDecoration расширяет WindowDecoration : // здесь необходимо «абстрактное переопределение», чтобы «super()» работало, поскольку родительская // функция является абстрактной. Если бы это было конкретно, обычного «переопределения» было бы достаточно. абстрактное переопределение def draw () println ( «in HorizontalScrollbarDecoration» ) super . draw () // теперь рисуем горизонтальную полосу прокрутки              черта ВертикальныйScrollbarDecoration расширяет WindowDecoration : абстрактное переопределение def draw () println ( «в ВертикальномScrollbarDecoration» ) super . draw () // теперь рисуем вертикальную полосу прокрутки            черта TitleDecoration расширяет WindowDecoration : абстрактное переопределение def draw () println ( «in TitleDecoration» ) super . draw () // теперь рисуем строку заголовка           

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

val mywin = новое SimpleWindow с вертикальным скроллбаром с горизонтальным скроллбаром с тайтломдекоратион          

Результат вызова mywin.draw():

в TitleDecoration в горизонтальной полосе прокруткиDecoration в вертикальной полосе прокруткиDecoration в SimpleWindow    

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

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

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

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

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

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

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

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

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

объект MyExtensions : расширение ( i : Int ) def isEven = i % 2 == 0 def isOdd = ! даже                 импортировать MyExtensions . _ // переносим неявное обогащение в область 4 . isEven // -> правда   

Импорт членов MyExtensionsвводит неявное преобразование в класс расширения IntPredicatesв область видимости. ^[42]

Параллелизм

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

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

val echoServer = актер ( новый акт : стать : случай msg => println ( «echo» + msg ) )           эхосервер ! "привет"  

Scala также имеет встроенную поддержку параллельного программирования данных в форме параллельных коллекций ^[46], интегрированных в стандартную библиотеку начиная с версии 2.9.0.

В следующем примере показано, как использовать параллельные коллекции для повышения производительности. ^[47]

val urls = List ( "https://scala-lang.org" , "https://github.com/scala/scala" )    def fromURL ( url : String ) = scala . ио . Источник . fromURL ( URL ) . получитьлинии (). mkString ( «\n» )     вал т = Система . URL-адреса currentTimeMillis () . пар . map ( fromURL ( _ )) // par возвращает параллельную реализацию коллекции println ( "time: " + ( System . currentTimeMillis - t ) + "ms" )          

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

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

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

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

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

Версии

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

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

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

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

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

Принятие

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

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

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

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

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

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

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

Компании

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

• Apple Inc. использует Scala в некоторых командах наряду с Java и платформой Play. ^{[135] [136]}
• В апреле 2011 года популярный веб-сайт Guardian.co.uk ^{[137] газеты} Guardian объявил о переходе с Java на Scala. ^{[138] [139]}
• В 2014 году газета New York Times сообщила, что ее внутренняя система управления контентом Blackbeard построена с использованием Scala, Akka и Play. ^[140]
• Газета Huffington Post начала использовать Scala как часть своей системы доставки контента Athena в 2013 году. ^[141]
• Швейцарский банк UBS одобрил Scala для общего производственного использования. ^[142]
• LinkedIn использует микрофреймворк Scalatra для реализации своего Signal API. ^[143]
• Meetup использует набор инструментов Unfiltered для API реального времени. ^[144]
• Помните, что Milk использует набор инструментов Unfiltered, Scala и Akka для общедоступного API и обновлений в реальном времени. ^[145]
• Verizon стремится создать «фреймворк следующего поколения» с использованием Scala. ^[146]
• Airbnb разрабатывает программное обеспечение для машинного обучения с открытым исходным кодом Aerosolve, написанное на Java и Scala. ^[147]
• Zalando перенесла свой технологический стек с Java на Scala и Play. ^[148]
• SoundCloud использует Scala для своей серверной части, применяя такие технологии, как Finagle (микросервисы), ^[149] Scalding и Spark (обработка данных). ^[150]
• Databricks использует Scala для платформы больших данных Apache Spark .
• Morgan Stanley широко использует Scala в своих проектах, связанных с финансами и активами. ^[151]
• В Google и Alphabet Inc. есть команды , которые используют Scala, в основном благодаря приобретениям таких компаний, как Firebase ^[152] и Nest. ^[153]
• Walmart Canada использует Scala в качестве внутренней платформы. ^[154]
• Duolingo использует Scala для своего внутреннего модуля, генерирующего уроки. ^[155]
• HMRC использует Scala для многих налоговых заявок правительства Великобритании. ^[156]
• M1 Finance использует Scala в качестве внутренней платформы. ^[157]

Критика

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

Смотрите также

• Портал бесплатного программного обеспечения с открытым исходным кодом
• Портал компьютерного программирования

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

Рекомендации

1. «Выпуск 2.13.12». 11 сентября 2023 г. Проверено 19 сентября 2023 г.
2. Ошибка: невозможно правильно отобразить ссылку. Подробности смотрите в документации .
3. «Файл уведомления» . Гитхаб . 24 января 2019 г. Проверено 4 декабря 2019 г.
4. "Макросы Скала".
5. Фогус, Майкл (6 августа 2010 г.). «Мартин Одерский возьми(5) в список». Отправьте больше парамедиков . Проверено 9 февраля 2012 г.
6. Одерский, Мартин (11 января 2006 г.). «Эксперимент Scala: можем ли мы обеспечить лучшую языковую поддержку для компонентных систем?» (PDF) . Проверено 22 июня 2016 г.
7. Одерский, Мартин; и другие. (2006). «Обзор языка программирования Scala» (PDF) (2-е изд.). Федеральная политехническая школа Лозанны (EPFL). Архивировано (PDF) из оригинала 9 июля 2020 г.
8. Одерский, Мартин (2008). Программирование на Scala. Маунтин-Вью, Калифорния: Артима. п. 3. ISBN 9780981531601. Проверено 12 июня 2014 г.
9. Потвин, Паскаль; Бонха, Марио (24 сентября 2015 г.). SDL 2013: Проектирование надежности на основе моделей . Конспекты лекций по информатике. Том. 7916. arXiv : 1509.07326 . дои : 10.1007/978-3-642-38911-5. ISBN 978-3-642-38910-8. S2CID  1214469.
10. «Часто задаваемые вопросы: совместимость Java» . Scala-lang.org . Проверено 6 февраля 2015 г.
11. Мартин Одерски (17 июня 2020 г.). Мартин Одерски: Обновление Scala 3 (видео). YouTube. Событие происходит в 36:35–45:08. Архивировано из оригинала 21 декабря 2021 г. Проверено 24 апреля 2021 г.
12. «Эффект эксп». скала . Проверено 31 июля 2022 г.
13. Ловердо, Христос (2010). Шаги в Scala: введение в объектно-функциональное программирование. Издательство Кембриджского университета . п. xiii. ISBN 9781139490948. Проверено 31 июля 2014 г.
14. Одерский, Мартин (9 июня 2006 г.). «Краткая история Scala». Artima.com .
15. Одерский, М.; Ромпф, Т. (2014). «Объединение функционального и объектно-ориентированного программирования со Scala». Коммуникации АКМ . 57 (4): 76. дои : 10.1145/2591013 .
16. Мартин Одерски, «Спецификация языка Scala, версия 2.7»
17. «Команда Scala выигрывает грант ERC» . Проверено 4 июля 2015 г.
18. «Коммерческая поддержка Scala». 12 мая 2011 г. Проверено 18 августа 2011 г.
19. «Почему мы инвестировали в Typesafe: современные приложения требуют современных инструментов» . 12 мая 2011 г. Проверено 8 мая 2018 г.
20. «Scala с открытым исходным кодом получает коммерческую поддержку» . 12 мая 2011 г. Проверено 9 октября 2011 г.
21. «Пионер облачных вычислений Мартин Одерски представляет свою новую компанию Typesafe» . 12 мая 2011 г. Проверено 24 августа 2011 г.
22. «Скала на Android». Архивировано из оригинала 20 июня 2016 года . Проверено 8 июня 2016 г.
23. «Scala 2.12.8 теперь доступна!». 04.12.2018 . Проверено 9 декабря 2018 г.
24. «Scala Js больше не является экспериментальным | Язык программирования Scala» . Scala-lang.org . Проверено 28 октября 2015 г.
25. «Релизы · scala-js/Scala-js» . Гитхаб .
26. Криль, Пол (15 марта 2017 г.). «Уменьшенный вариант Scala разрывает связь с JVM». Инфомир . Проверено 21 марта 2017 г.
27. Криль, Пол (11 мая 2016 г.). «Язык Scala приближается к голому железу». Инфомир .
28. Удалена серверная часть .net. от paulp · Запрос на извлечение № 1718 · scala/scala · GitHub. Github.com (5 декабря 2012 г.). Проверено 2 ноября 2013 г.
29. «Начало работы со Scala». Scala-lang.org . 15 июля 2008 года . Проверено 31 июля 2014 г.
30. «Дом». Блог.lostlake.org. Архивировано из оригинала 31 августа 2010 года . Проверено 25 июня 2013 г.
31. Встроенные структуры управления Scala, такие как ifили whileне могут быть повторно реализованы. Существует исследовательский проект Scala-Virtualized, направленный на устранение этих ограничений: Адриан Мурс, Тиарк Ромпф, Филипп Халлер и Мартин Одерски. Scala-виртуализация. Материалы семинара ACM SIGPLAN 2012 по частичной оценке и манипуляциям с программой , 117–120. Июль 2012.
32. «Прокачай мою библиотеку». Артима.com. 09.10.2006 . Проверено 25 июня 2013 г.
33. «Выражения | Scala 2.13» . scala-lang.org . Проверено 24 мая 2021 г.
34. «Изменяемые и неизменяемые коллекции — документация Scala» . Проверено 30 апреля 2020 г.
35. «Коллекции — Конкретные неизменяемые классы коллекций — Документация Scala» . Проверено 4 июля 2015 г.
36. Догерти, Рич. «Блог Рича Догерти» . Проверено 4 июля 2015 г.
37. «TailCalls — API стандартной библиотеки Scala (Scaladoc) 2.10.2 — scala.util.control.TailCalls» . Scala-lang.org . Проверено 25 июня 2013 г.
38. «Системы типов Java и Scala ненадежны» (PDF) .
39. Джарруссо, Паоло Г. (2013). «Уточните свои запросы коллекции для обеспечения модульности и скорости!». Материалы 12-й ежегодной международной конференции по аспектно-ориентированной разработке программного обеспечения . АКМ. arXiv : 1210.6284 . Бибкод : 2012arXiv1210.6284G. Также известен как шаблон «Прокачай мою библиотеку».
40. Гилберт, Клинт (15 ноября 2011 г.). «Что является наивысшим приоритетом для успеха Scala в корпоративном мире (должно быть в дебатах по Scala?)?». Scala-lang.org . Проверено 8 мая 2019 г.
41. «Должны ли мы «обогащать» или «прокачивать» библиотеки Scala?». stackexchange.com . 17 июня 2013 года . Проверено 15 апреля 2016 г.
42. Неявные классы были введены в Scala 2.10, чтобы сделать расширения методов более краткими. Это эквивалентно добавлению метода implicit def IntPredicate(i: Int) = new IntPredicate(i). Класс также может быть определен как implicit class IntPredicates(val i: Int) extends AnyVal { ... }, создавая так называемый класс значений , также представленный в Scala 2.10. Затем компилятор исключит фактические экземпляры и вместо этого создаст статические методы, что позволит методам расширения практически не нагружать производительность.
43. Что такое Akka?, Онлайн-документация Akka.
44. Суфрин, Бернард (2008). «Взаимодействие с объектами Scala». В Уэлче, штат Пенсильвания; Степни, С.; Поляк, КВС; Барнс, ФРМ; Макьюэн, А.А.; Стайлз, GS; Броэнинк, Дж. Ф.; Сэмпсон, AT (ред.). Архитектуры процессов связи 2008: WoTUG-31 (PDF) . ИОС Пресс. ISBN 978-1586039073.
45. Ян, Кей. «Скала Тур» . Проверено 4 июля 2015 г.
46. "Parallelcollections - Обзор - Документация Scala" . Docs.scala-lang.org . Проверено 25 июня 2013 г.
47. Ян, Кей. «Скала Тур» . Проверено 4 июля 2015 г.
48. Изучение параллельного программирования в Scala, Александр Прокопец, Packt Publishing
49. Копс, Миша (13 января 2013 г.). «Краткое введение в ScalaTest». hascode.com . Проверено 7 ноября 2014 г.
50. Нильссон, Рикард (17 ноября 2008 г.). «СкалаЧек 1.5». Scala-lang.org . Проверено 7 ноября 2014 г.
51. «Создавайте веб-приложения с использованием Scala и Play Framework». www.workwithplay.com . 22 мая 2013 г. Проверено 7 ноября 2014 г.
52. Мясник, Пол (4 июня 2012 г.). «Предварительный выпуск ScalaMock 3.0». paulbutcher.com . Архивировано из оригинала 08.11.2014 . Проверено 7 ноября 2014 г.
53. «История изменений Scala». Scala-lang.org . Архивировано из оригинала 9 октября 2007 г.
54. «Удален: XML-литералы» . dotty.epfl.ch . Проверено 05 марта 2021 г.
55. «Изменения в версии 2.0 (12 марта 2006 г.)» . Scala-lang.org . 12 марта 2006 г. Проверено 7 ноября 2014 г.
56. «Изменения в версии 2.1.8 (23 августа 2006 г.)» . Scala-lang.org . 23 августа 2006 г. Проверено 7 ноября 2014 г.
57. «Изменения в версии 2.3.0 (23 ноября 2006 г.)» . Scala-lang.org . 23 ноября 2006 г. Проверено 7 ноября 2014 г.
58. «Изменения в версии 2.4.0 (9 марта 2007 г.)» . Scala-lang.org . 9 марта 2007 г. Проверено 7 ноября 2014 г.
59. «Изменения в версии 2.5 (02 мая 2007 г.)» . Scala-lang.org . 2 мая 2007 г. Проверено 7 ноября 2014 г.
60. «Изменения в версии 2.6 (27 июля 2007 г.)» . Scala-lang.org . 27 июня 2007 г. Проверено 7 ноября 2014 г.
61. «Изменения в версии 2.7.0 (7 февраля 2008 г.)» . Scala-lang.org . 07 февраля 2008 г. Проверено 7 ноября 2014 г.
62. «Изменения в версии 2.8.0 (14 июля 2010 г.)» . Scala-lang.org . 10 июля 2010 г. Проверено 7 ноября 2014 г.
63. «Изменения в версии 2.9.0 (12 мая 2011 г.)» . Scala-lang.org . 12 мая 2011 г. Проверено 7 ноября 2014 г.
64. «Изменения в версии 2.10.0». Scala-lang.org . 04.01.2013 . Проверено 7 ноября 2014 г.
65. Харра, Марк. «Классы ценностей и универсальные черты». Scala-lang.org . Проверено 7 ноября 2014 г.
66. Суэрет, Джош. «SIP-13 — Неявные классы». Scala-lang.org . Архивировано из оригинала 08.11.2014 . Проверено 7 ноября 2014 г.
67. Суэрет, Джош. «Строковая интерполяция». Scala-lang.org . Проверено 7 ноября 2014 г.
68. Халлер, Филипп; Прокопец, Александр. «Будущее и обещания». Scala-lang.org . Проверено 7 ноября 2014 г.
69. "SIP-17 - Тип динамический" . Scala-lang.org . Архивировано из оригинала 08.11.2014 . Проверено 7 ноября 2014 г.
70. «SIP-18 — Модуляция языковых функций» . Scala-lang.org . Архивировано из оригинала 08.11.2014 . Проверено 7 ноября 2014 г.
71. Прокопец, Александр; Миллер, Хизер. «Параллельные коллекции». Scala-lang.org . Проверено 7 ноября 2014 г.
72. Миллер, Хизер; Бурмако, Евгений. «Обзор отражений». Scala-lang.org . Проверено 7 ноября 2014 г.
73. Бурмако, Евгений. «Макросы определения». Scala-lang.org . Проверено 7 ноября 2014 г.
74. «Scala 2.10.2 теперь доступна!». Scala-lang.org . 06.06.2013. Архивировано из оригинала 08.11.2014 . Проверено 7 ноября 2014 г.
75. «Scala 2.10.3 теперь доступна!». Scala-lang.org . 01.10.2013. Архивировано из оригинала 08.11.2014 . Проверено 7 ноября 2014 г.
76. «Scala 2.10.4 теперь доступна!». Scala-lang.org . 18 марта 2014 г. Проверено 7 января 2015 г.
77. «Scala 2.10.5 теперь доступна!». Scala-lang.org . 04.03.2015 . Проверено 23 марта 2015 г.
78. «Scala 2.11.0 теперь доступна!». Scala-lang.org . 21 апреля 2014 г. Проверено 7 ноября 2014 г.
79. «Scala 2.11.1 теперь доступна!». Scala-lang.org . 20 мая 2014 г. Проверено 7 ноября 2014 г.
80. «Scala 2.11.2 теперь доступна!». Scala-lang.org . 22 июля 2014 г. Проверено 7 ноября 2014 г.
81. «Scala 2.11.4 теперь доступна!». Scala-lang.org . 30 октября 2014 г. Проверено 7 ноября 2014 г.
82. «Scala 2.11.5 теперь доступна!». Scala-lang.org . 08.01.2015 . Проверено 22 января 2015 г.
83. «Scala 2.11.6 теперь доступна!». Scala-lang.org . 05.03.2015 . Проверено 12 марта 2015 г.
84. «Scala 2.11.7 теперь доступна!». Scala-lang.org . 23 июня 2015 г. Проверено 3 июля 2015 г.
85. «Scala 2.11.8 теперь доступна!». Scala-lang.org . 08.03.2016 . Проверено 9 марта 2016 г.
86. «Три новых релиза и еще больше добра GitHub!». Scala-lang.org . 18 апреля 2017 г. Проверено 19 апреля 2017 г.
87. «Обновление безопасности: 2.12.4, 2.11.12, 2.10.7 (CVE-2017-15288)» . Scala-lang.org . 13.11.2017 . Проверено 4 мая 2018 г.
88. «Scala 2.12.0 теперь доступна!». Scala-lang.org . 03.11.2016 . Проверено 8 января 2017 г.
89. «Scala 2.12.1 теперь доступна!». Scala-lang.org . 05.12.2016 . Проверено 08 января 2017 г.
90. «Scala 2.12.3 теперь доступна!». Scala-lang.org . 26 июля 2017 г. Проверено 16 августа 2017 г.
91. «Scala 2.12.4 теперь доступна!». Scala-lang.org . 18 октября 2017 г. Проверено 26 октября 2017 г.
92. «Скала 2.12.5 теперь доступна!». Scala-lang.org . 15 марта 2018 г. Проверено 20 марта 2018 г.
93. «Scala 2.12.6 теперь доступна!». Scala-lang.org . 27 апреля 2018 г. Проверено 4 мая 2018 г.
94. «Scala 2.12.7 теперь доступна!». Scala-lang.org . 27 сентября 2018 г. Проверено 9 октября 2018 г.
95. «Scala 2.12.8 теперь доступна!». Scala-lang.org . 04.12.2018 . Проверено 9 декабря 2018 г.
96. «Scala 2.12.9 теперь доступна!». Scala-lang.org . 05.08.2019 . Проверено 20 января 2021 г.
97. «Scala 2.12.10 теперь доступна!». Scala-lang.org . 10 сентября 2019 г. Проверено 20 января 2021 г.
98. «Scala 2.12.11 теперь доступна!». Scala-lang.org . 16 марта 2020 г. Проверено 20 января 2021 г.
99. «Scala 2.12.12 теперь доступна!». Scala-lang.org . 13 июля 2020 г. Проверено 20 января 2021 г.
100. «Scala 2.12.13 теперь доступна!». Scala-lang.org . 12 января 2021 г. Проверено 20 января 2021 г.
101. «Scala 2.12.14 теперь доступна!». Scala-lang.org . 28 мая 2021 г. Проверено 15 апреля 2022 г.
102. «Scala 2.12.15 теперь доступна!». Scala-lang.org . 14 сентября 2021 г. Проверено 19 июня 2022 г.
103. «Скала 2.12.16 теперь доступна!». Scala-lang.org . 10 июня 2022 г. Проверено 19 июня 2022 г.
104. «Scala 2.12.17 теперь доступна!». Scala-lang.org . 10 июня 2022 г. Проверено 16 сентября 2022 г.
105. «Scala 2.12.18 теперь доступна!». Scala-lang.org . 10 июня 2022 г. Проверено 7 июня 2023 г.
106. «Scala 2.13.0 теперь доступна!». Scala-lang.org . 11.06.2019 . Проверено 17 июня 2018 г.
107. «Scala 2.13.1 теперь доступна!». Scala-lang.org . 18 сентября 2019 г. Проверено 20 января 2021 г.
108. «Scala 2.13.2 теперь доступна!». Scala-lang.org . 22 апреля 2020 г. Проверено 20 января 2021 г.
109. «Scala 2.13.3 теперь доступна!». Scala-lang.org . 25 июня 2020 г. Проверено 20 января 2021 г.
110. «Scala 2.13.4 теперь доступна!». Scala-lang.org . 19.11.2020 . Проверено 20 января 2021 г.
111. «Scala 2.13.5 теперь доступна!». Scala-lang.org . 2021-02-22 . Проверено 26 февраля 2021 г.
112. «Scala 2.13.6 теперь доступна!». Scala-lang.org . 17 мая 2021 г. Проверено 15 апреля 2022 г.
113. «Scala 2.13.7 теперь доступна!». Scala-lang.org . 01.11.2021 . Проверено 15 апреля 2022 г.
114. «Scala 2.13.8 теперь доступна!». Scala-lang.org . 12 января 2022 г. Проверено 15 апреля 2022 г.
115. «Scala 2.13.9 теперь доступна!». Scala-lang.org . 21 сентября 2022 г. Проверено 28 августа 2023 г.
116. «Scala 2.13.10 теперь доступна!». Scala-lang.org . 13 октября 2022 г. Проверено 28 августа 2023 г.
117. «Scala 2.13.11 теперь доступна!». Scala-lang.org . 07.06.2023 . Проверено 28 августа 2023 г.
118. «Scala 3 уже здесь!». Scala-lang.org . 14 мая 2021 г. Проверено 26 мая 2021 г.
119. "Скала 3.1.2" . Scala-lang.org . 12 апреля 2022 г. Проверено 19 июня 2022 г.
120. "Скала 3.2.2" . Scala-lang.org . 30 января 2023 г. Проверено 28 августа 2023 г.
121. "Скала 3.3.0" . Scala-lang.org . 30 мая 2023 г. Проверено 28 августа 2023 г.
122. «Часто задаваемые вопросы о технологических радарах ThinkWorks» .
123. «Технологический радар ThinkWorks, МАЙ 2013 г.» (PDF) .
124. «Скала, хорошие стороны» .
125. «Состояние Явы в 2018 году».
126. «Индекс популярности языков программирования» .
127. О'Грейди, Стивен (1 марта 2021 г.). «Рейтинг языков программирования RedMonk: январь 2021 г.». РедМонк .
128. «Индекс TIOBE за май 2021 года».
129. Грин, Кейт (1 апреля 2009 г.). «Секрет роста Twitter: как новый язык веб-программирования помогает компании справиться с растущей популярностью». Обзор технологий . Массачусетский технологический институт . Проверено 6 апреля 2009 г.
130. Брек, Колин; Линк, Перси (23 марта 2020 г.). «Виртуальная электростанция Тесла (архитектура и дизайн)» . Проверено 28 марта 2023 г.
131. «Исходный код Apache Kafka на GitHub» . Фонд программного обеспечения Apache . Проверено 29 марта 2023 г.
132. «Play Framework, Akka и Scala в Gilt Groupe» . Изгиб света. 15 июля 2013 года . Проверено 16 июля 2016 г.
133. «Скала, лифт и будущее». Архивировано из оригинала 13 января 2016 года . Проверено 4 июля 2015 г.
134. Саэта, Бреннан (17 февраля 2014 г.). «Почему мы любим Scala на Coursera». Курсера Инжиниринг . Проверено 21 сентября 2023 г.
135. "Премьер-министр Apple по инженерным вопросам Джаррод Неттлс в Твиттере" . Джаррод Неттлз . Проверено 11 марта 2016 г.
136. «30 вакансий Scala в Apple» . Элвин Александр . Проверено 11 марта 2016 г.
137. Дэвид Рид и Таня Тейшейра (26 февраля 2010 г.). «Готовы ли люди платить за онлайн-новости?». Би-би-си . Проверено 28 февраля 2010 г.
138. «Переключение Guardian с Java на Scala» . Хейзе онлайн . 05 апреля 2011 г. Проверено 5 апреля 2011 г.
139. "Guardian.co.uk Переход с Java на Scala" . InfoQ.com. 04.04.2011 . Проверено 5 апреля 2011 г.
140. Рой, Суман; Сундаресан, Кришна (13 мая 2014 г.). «Создание Blackbeard: система синдикации на базе Play, Scala и Akka». Нью-Йорк Таймс . Проверено 20 июля 2014 г.
141. Павли, Джон (11 августа 2013 г.). «Краткий обзор: HuffPost обеспечивает совместную работу в отделе новостей в режиме реального времени». Хаффингтон Пост . Проверено 20 июля 2014 г.
142. Бинсток, Эндрю (14 июля 2011 г.). «Интервью с Мартином Одерски из Scala». Журнал доктора Добба . Проверено 10 февраля 2012 г.
143. Синодинос, Дионисий Г. (11 октября 2010 г.). «Сигнал LinkedIn: пример использования Scala, JRuby и Voldemort». ИнфоQ .
144. «Реальные встречи заслуживают API реального времени» .
145. «В веб-приложении Remember The Milk появляется обновление в реальном времени» .
146. «ЧТО ТАКОЕ СКАЛА» . 8 марта 2023 г. Проверено 17 марта 2023 г.
147. Новет, Иордания (4 июня 2015 г.). «Airbnb анонсирует Aerosolve, пакет программного обеспечения для машинного обучения с открытым исходным кодом» . Проверено 9 марта 2016 г.
148. Копс, Александр (14 декабря 2015 г.). «Zalando Tech: от Java до Scala менее чем за три месяца» . Проверено 9 марта 2016 г.
149. Кальсадо, Фил (13 июня 2014 г.). «Создание продуктов в SoundCloud — Часть III: Микросервисы в Scala и Finagle» . Проверено 9 марта 2016 г.
150. «Исследования клиентов: SoundCloud» . Компания Concurrent Inc. 18 ноября 2014 г. Проверено 9 марта 2016 г.
151. Scala в Morgan Stanley (видео). Навыки имеют значение. 03.12.2015 . Проверено 11 марта 2016 г.
152. Грег Солтис (3 декабря 2015 г.). SF Scala, Грег Солтис: Высокопроизводительные сервисы в Scala (видео). Навыки имеют значение. Архивировано из оригинала 21 декабря 2021 г. Проверено 11 марта 2016 г.
153. Ли Майдолл. «Вакансии Scala в Nest» . Проверено 11 марта 2016 г.
154. Нурун. «Нурун запускает обновленную транзакционную платформу совместно с Walmart Canada» . Проверено 11 декабря 2013 г.
155. Хори, Андре К. (31 января 2017 г.). «Переписывание движка Duolingo на Scala» . Проверено 3 февраля 2017 г.
156. "Репозиторий HMRC GitHub" . Гитхаб .
157. «Знакомьтесь с M1 Finance, золотым спонсором ScalaCon» . СкалаКон . Проверено 2 сентября 2023 г.
158. Хейл, Кода (29 ноября 2011 г.). «Остальная часть истории». codahale.com . Проверено 7 ноября 2013 г.
159. Крикорян, Раффи (17 марта 2015 г.). Конференция O'Reilly по архитектуре программного обеспечения 2015. Полный сборник видео: Ре-архитектура на лету - Раффи Крикорян - Часть 3 (видео). О'Рейли Медиа. Событие происходит в 4:57 . Проверено 8 марта 2016 г. Что я бы сделал по-другому четыре года назад, так это использовал бы Java, а не Scala в рамках этой переписывания. [...] инженеру потребуется два месяца, прежде чем он сможет полностью продуктивно начать писать код Scala.^{[ постоянная мертвая ссылка ]}
160. Скотт, Кевин (11 марта 2015 г.). «Избавляется ли LinkedIn от Scala?». quora.com . Проверено 25 января 2016 г.
161. «Долото: создание оборудования на встроенном языке Scala» . APSIRE Калифорнийского университета в Беркли . Проверено 27 мая 2020 г.

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

• Одерский, Мартин; Ложка, Лекс; Веннерс, Билл (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. ИСБН 978-1-935182-70-2.
• Мередит, Грегори (2011). Монадические шаблоны проектирования для Интернета (PDF) (1-е изд.). п. 300.
• Одерский, Мартин; Ложка, Лекс; Веннерс, Билл (10 декабря 2008 г.). Программирование на Scala, электронная книга (1-е изд.). Артима Инк.