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

Scala

Парадигма	Мультипарадигма : параллельный , функциональный , императивный , объектно-ориентированный
Разработано	Мартин Одерский
Разработчик	Лаборатория методов программирования Федеральной политехнической школы Лозанны
Впервые появился	20 января 2004 г . ; 17 лет назад ( 2004-01-20 )
Стабильный выпуск	2.13.4 / 19 ноября 2020 г . ; 2 месяца назад [1] ( 2020-11-19 )
Печатная дисциплина	Предполагаемый , статический , прочный , структурный
Язык реализации	Scala
Платформа	JVM JavaScript ( Scala.js ) LLVM ( Scala Native ) (экспериментальный)
Лицензия	Лицензия Apache 2.0 [2]
Расширения имени файла	.scala, .sc
Интернет сайт	www .scala-lang .org
Под влиянием
Common Lisp , [3] Eiffel , Erlang , Haskell , [4] Java , [5] OCaml , [5] Oz , Pizza , [6] Scheme , [5] Smalltalk , Standard ML [5]
Под влиянием
Цейлон , Фантом , F # , Котлин , Лассо , Красный
Scala в Викиучебнике

Скала ( / с к ɑː л ɑː / SKAH -lah ) ^[7] является языком программирования общего назначения , обеспечивая поддержку как объектно-ориентированного программирования и функционального программирования . В языке есть сильная система статических типов . Созданный для краткости ^[8], многие проектные решения Scala направлены на устранение критики Java . ^[6]

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

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

История [ править ]

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

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

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

Платформы и лицензия [ править ]

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

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

Другие компиляторы и цели [ править ]

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

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

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

Примеры [ править ]

Пример "Hello World" [ править ]

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

 объект  HelloWorld  расширяет  приложение  {  println ( "Hello, World!" )  }

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

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

$ scalac HelloWorld.scala

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

$ scala HelloWorld

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

Более короткая версия программы "Hello World" на Scala:

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

Scala включает интерактивную оболочку и поддержку сценариев. ^[27] Сохраненный в файле с именем 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). Введите выражения для оценки. Или попробуйте: помогите.scala> List (1, 2, 3) .map (x => x * x) res0: List [Int] = List (1, 4, 9)scala>

Базовый пример [ править ]

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

// Java: int  mathFunction ( int  num )  {  int  numSquare  =  num * num ;  return  ( int )  ( Math . cbrt ( numSquare )  +  Math . журнал ( numSquare )); }

// Scala: прямое преобразование из Java// импорт не требуется; scala.math // уже импортирован как `math` def  mathFunction ( num :  Int ) :  Int  =  {  var  numSquare :  Int  =  num * num  return  ( math . cbrt ( numSquare )  +  math . log ( numSquare )).  asInstanceOf [ Int ] }

// Scala: более идиоматический // Использует вывод типа, опускает оператор return, // использует метод toInt, объявляет неизменяемым numSquareimport  math._ def  mathFunction ( num :  Int )  =  {  val  numSquare  =  num * num  ( cbrt ( numSquare )  +  log ( numSquare )). toInt }

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

• Scala не требует точки с запятой в конце операторов.
• Типы значений пишутся с заглавной буквы: Int, Double, Booleanвместо int, double, boolean.
• Параметр и возвращаемые типы следуют, как в Паскале , а не предшествуют , как и в 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>.
• Вместо псевдотипа в voidScala есть фактический одноэлементный класс Unit (см. Ниже).

Пример с классами [ править ]

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

// Java: открытый  класс  Point  {  частный  конечный  двойной  x ,  y ; public  Point ( последний  двойной  x ,  последний  двойной  y )  {  this . х  =  х ;  это . у  =  у ;  } общедоступная  точка (  конечный  двойной  x ,  последний  двойной  y ,  конечный  логический  addToGrid  )  {  this ( x ,  y ); если  ( addToGrid )  сетка . добавить ( это );  } общественная  точка ()  {  это ( 0,0 ,  0,0 );  } public  double  getX ()  {  вернуть  х ;  } public  double  getY ()  {  вернуть  y ;  } double  distanceToPoint ( final  Point  other )  {  вернуть  distanceBetweenPoints ( x ,  y ,  other . x ,  other . y );  } частная  статическая  сетка  Grid  =  new  Grid (); static  double  distanceBetweenPoints (  final  double  x1 ,  final  double  y1 ,  final  double  x2 ,  final  double  y2  )  {  return  Math . гипотеза ( x1  -  x2 ,  y1  -  y2 );  } }

// Scala класс  Point (  val  x :  Double ,  val  y :  Double ,  addToGrid :  Boolean  =  false )  {  import  Point._ если  ( addToGrid )  сетка . добавить ( это ) def  this ()  =  это ( 0,0 ,  0,0 ) def  distanceToPoint ( other :  Point )  =  distanceBetweenPoints ( x ,  y ,  other . x ,  other . y ) }объект  Point  {  private  val  grid  =  new  Grid () def  distanceBetweenPoints ( x1 :  Double ,  y1 :  Double ,  x2 :  Double ,  y2 :  Double )  =  {  math . гипотеза ( x1  -  x2 ,  y1  -  y2 )  } }

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

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

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

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

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

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

Синтаксическая гибкость [ править ]

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

• Точки с запятой не нужны; строки автоматически соединяются, если они начинаются или заканчиваются маркером, который обычно не может стоять в этой позиции, или если есть незакрытые круглые скобки или скобки.
• Любой метод может использоваться как инфиксный оператор, например, "%d apples".format(num)и "%d apples" format numэквивалентны. Фактически, арифметические операторы, такие как +и <<, обрабатываются так же, как и любые другие методы, поскольку имена функций могут состоять из последовательностей произвольных символов (за некоторыми исключениями, сделанными для таких вещей, как скобки, скобки и скобки, которые должны обрабатываться особым образом); единственная особая обработка, которой подвергаются такие именованные с помощью символов методы, касается обработки приоритета.
• Методы applyи updateимеют синтаксические краткие формы. foo()-Где fooпредставляет собой значение (Singleton объекта или экземпляра класса) -это короткий для foo.apply(), и foo() = 42это сокращение foo.update(42). Точно так же foo(42)это сокращение от foo.apply(42)и foo(4) = 2является сокращением от foo.update(4, 2). Это используется для классов коллекций и распространяется на многие другие случаи, такие как ячейки STM .
• Scala различает методы no-parens ( def foo = 42) и empty-parens ( 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
• В вызовах методов разрешено использование фигурных скобок вместо круглых. Это позволяет реализовать новые управляющие структуры в чистом виде. ^[29] Например, 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 между примитивными типами и упакованными типами (например, intvs. Integer) в Scala отсутствует; упаковка и распаковка полностью прозрачны для пользователя. Scala 2.10 позволяет пользователю определять новые типы значений.

Фор-выражения [ править ]

Вместо циклов « foreach » Java для прохождения цикла через итератор в 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 как метод расширения для целых чисел с использованием техники, известной как неявные преобразования ^[30], которая позволяет добавлять новые методы к существующим типам.)

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

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

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

Функциональные тенденции [ править ]

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

Примеры:

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

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

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

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

// Java: int  hexDigit  =  x  > =  10  ?  х  +  'А'  -  10  :  х  +  '0' ;

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

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

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

def  printValue ( x :  String ) :  Unit  =  {  println ( "Я съел% s" . format ( x )) }

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

def  printValue ( x :  String )  =  println ( "Я съел% s"  формат  x )

Вывод типа [ править ]

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

def  formatApples ( x :  Int )  =  «Я съел% d яблок» . формат ( x )

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

def  factorial ( x :  Int ) :  Int  =  if  ( x  ==  0 )  1  else  x * факториал ( x  -  1 )

Анонимные функции [ править ]

В Scala функции являются объектами, и существует удобный синтаксис для указания анонимных функций . Примером является выражение x => x < 2, которое определяет функцию с одним параметром, который сравнивает свой аргумент, чтобы увидеть, меньше ли он 2. Оно эквивалентно форме Лиспа (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. Однако следует отметить, что они valявляются лишь поверхностно неизменяемыми, то есть объект, на который ссылается val, не гарантирует неизменяемость самого себя.

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

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

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

Хвостовая рекурсия [ править ]

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

Классы регистра и сопоставление с образцом [ править ]

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

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

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

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

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выражений с преобладающим первым совпадающим выражением, аналогично телу оператора switch . Частичные функции также используются в части tryоператора, обрабатывающей исключения :

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

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

val  qsort :  List [ Int ]  =>  List [ Int ]  =  {  case  Nil  =>  Nil  case  pivot  ::  tail  =>  val  ( меньше ,  остальное )  =  хвост . раздел ( _  <  pivot )  qsort ( меньше )  :::  pivot  ::  qsort ( rest ) }

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

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

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

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

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

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

Переменная может быть объявлена ​​так:

val  mywin  =  new  SimpleWindow  с  VerticalScrollbarDecoration  с  HorizontalScrollbarDecoration  с  TitleDecoration

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

в  TitleDecoration в  HorizontalScrollbarDecoration в  VerticalScrollbarDecoration в  SimpleWindow

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

Система экспрессивных шрифтов [ править ]

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

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

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

Обогащение типов [ править ]

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

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

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

объект  MyExtensions  {  неявный  класс  IntPredicates ( i :  Int )  {  def  isEven  =  i  %  2  ==  0  def  isOdd  =  ! isEven  } }import  MyExtensions._  // неявное обогащение в области 4. isEven  // -> true

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

Параллелизм [ править ]

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

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

вал  echoServer  =  актер ( новый  закон  {  стать  {  случай  тзд  =>  Println ( "эхо"  +  тзд )  } }) echoServer  !  "Здравствуй"

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

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

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

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

Кластерные вычисления [ править ]

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

Тестирование [ править ]

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

Версии [ править ]

Сравнение с другими языками JVM [ править ]

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

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

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

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

Принятие [ править ]

Рейтинг языков [ править ]

По состоянию на 2013 год ^{[Обновить]}все языки на основе JVM (Clojure, Groovy, Kotlin, Scala) значительно менее популярны, чем исходный язык Java, который обычно занимает первое или второе место ^{[104] [105]} и который также одновременно развивается с течением времени. .

Индекс популярности языков программирования ^[106], который отслеживает поиск языковых руководств, поставил Scala на 15-е место в апреле 2018 г. с небольшой тенденцией к снижению и на 17-е место в январе 2021 г. Это делает Scala вторым по популярности языком на основе JVM после Java, с Kotlin , язык на основе JVM, занявший 12-е место.

Индекс популярности языков программирования TIOBE ^[105] использует рейтинги в поисковых системах и аналогичный подсчет публикаций для определения популярности языка. По состоянию на апрель 2018 года Scala занимает 34-е место, опустившись на четыре позиции за последние два года, но, как упоминалось в разделе «Ошибки и запросы на изменение», TIOBE знает о проблемах с его методологией использования условий поиска, которые могут не соответствовать обычно используется в некоторых сообществах языков программирования. В этом рейтинге Scala опережает некоторые функциональные языки, такие как Haskell (42-е место), Erlang , но уступает другим языкам, таким как Swift (15-е), Perl (16-е), Go (19-е) и Clojure (30-е).

ThoughtWorks Radar Technology, которая является мнение , основанное раз в два года доклад группы старших технологов, ^[107] рекомендовал принять Scala в языках и рамок категории в 2013 году ^[108] В июле 2014, эта оценка была сделана более конкретной и теперь относится на «Scala, хорошие части», который описывается как «Чтобы успешно использовать Scala, вам необходимо изучить язык и иметь очень твердое мнение о том, какие части вам подходят, создав свое собственное определение Scala, хорошие части . ". ^[109]

В рейтинге языков программирования RedMonk, который устанавливает рейтинг на основе количества проектов GitHub и вопросов, заданных на Stack Overflow , Scala занимает 14-е место. ^[104] Здесь Scala находится внутри второго эшелона группы языков, впереди Go , PowerShell и Haskell , а вслед за Swift , Objective-C , Машинопись и R . Однако в своем отчете за 2018 год рейтинги отметили падение рейтинга Scala в третий раз подряд, задав вопрос, «сколько из доступного кислорода для Scala потребляется Kotlin, поскольку последний продолжает подниматься в этом рейтинге». ^[104]

В исследовании «Состояние Java» за 2018 год ^{[110], в} котором были собраны данные от 5160 разработчиков по различным темам, связанным с Java, Scala занимает третье место по использованию альтернативных языков в JVM. По сравнению с прошлогодним опросом, использование Scala среди альтернативных языков JVM упало почти на четверть (с 28,4% до 21,5%), обогнав Kotlin, который вырос с 11,4% в 2017 году до 28,8% в 2018 году.

Компании [ править ]

• В апреле 2009 года Twitter объявил, что большую часть своей серверной части он переключил с Ruby на Scala и намеревается преобразовать остальную часть. ^[111]
• Gilt использует Scala и Play Framework . ^[112]
• Foursquare использует Scala и Lift . ^[113]
• Coursera использует Scala и Play Framework . ^[114]
• Apple Inc. использует Scala в определенных командах, а также Java и платформу Play. ^{[115] [116]}
• The Guardian сайтбольшим трафиком газеты guardian.co.uk ^[117] было объявлено в апреле 2011 годачто это был переход от Java в Scala. ^{[118] [119]}
• В 2014 году New York Times сообщила, что ее внутренняя система управления контентом Blackbeard построена с использованием Scala, Akka и Play. ^[120]
• Газета Huffington Post начала использовать Scala как часть своей системы доставки контента Athena в 2013 году ^[121].
• Швейцарский банк UBS одобрил Scala для общего производственного использования. ^[122]
• LinkedIn использует Scalatra микрокаркас для питания его API сигнала. ^[123]
• Meetup использует нефильтрованный инструментарий для API реального времени. ^[124]
• Помните, что Milk использует Unfiltered toolkit, Scala и Akka для общедоступного API и обновлений в реальном времени. ^[125]
• Verizon стремится создать «фреймворк нового поколения» с использованием Scala. ^[126]
• Airbnb разрабатывает программное обеспечение для машинного обучения с открытым исходным кодом Aerosolve, написанное на Java и Scala. ^[127]
• Zalando переместила свой стек технологий с Java на Scala и Play. ^[128]
• SoundCloud использует Scala для своей серверной части, используя такие технологии, как Finagle (микросервисы), ^[129] Scalding и Spark (обработка данных). ^[130]
• Databricks использует Scala для платформы больших данных Apache Spark .
• Morgan Stanley широко использует Scala в своих финансовых проектах и ​​проектах, связанных с активами. ^[131]
• В Google / Alphabet Inc. есть команды , использующие Scala, в основном благодаря таким приобретениям, как Firebase ^[132] и Nest. ^[133]
• Walmart Canada использует Scala в качестве серверной платформы. ^[134]
• Duolingo использует Scala в качестве внутреннего модуля, который генерирует уроки. ^[135]
• HMRC использует Scala для многих налоговых приложений правительства Великобритании. ^[136]

Критика [ править ]

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

См. Также [ править ]

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

Ссылки [ править ]

Дальнейшее чтение [ править ]

В Викиучебнике есть книга по теме: Scala