Scala это: Какое место занимает язык Scala в ИТ-индустрии / Хабр

Какое место занимает язык Scala в ИТ-индустрии / Хабр

Язык программирования Scala является «симбиозом» Java и C#. Это не первый язык, комбинирующий ООП с функциональным подходом, но он начал набирать обороты в тот момент, когда развитие Java замедлилось. Более того, создатели Scala решили, что язык должен работать на виртуальной машине JVM и предоставлять доступ к Java-библиотекам.

Мартин Одерски начал разрабатывать Scala в начале 2000-х в стенах Лаборатории методов программирования EPFL. Он же ранее занимался разработкой Generic Java и компилятора Java фирмы Sun.

Внутренний релиз Scala появился в 2003 году. Первый публичный релиз вышел в начале 2004 года на Java-платформе, а в июне того же года – на .NET Framework (правда, с 2012 года эта платформа не поддерживается). Scala 2.0 увидела свет в 2006 году. Его компиляторы и библиотеки распространяются под лицензией BSD.

Лицензия BSD (Berkeley Software Distribution license — Программная лицензия университета Беркли) — это лицензионное соглашение, впервые применённое для распространения UNIX-подобных операционных систем BSD.

17 января 2011 года команда разработчиков языка выиграла грант на исследование сроком в пять лет. Европейский исследовательский совет выделил им около €2,3 миллиона. В мае 2011-го участники сообщества Scala во главе с Одерским основали компанию Typesafe Inc. (в феврале 2016 года переименована в Lightbend Inc.). Созданная компания должна была осуществлять финансовую поддержку разработчиков, создавать сервисы для Scala. Зарабатывать Typesafe должна была на Scala-библиотеках. В 2011 году фирма получила $3 миллиона инвестиций от Greylock Partners.

Мартин Одерски — создатель Scala

Что «под капотом»

Язык Scala объединяет три вещи: статическую типизацию, объектно-ориентированный и функциональный подход. Как уже говорилось, Scala работает на виртуальной машине Java. Совместимость («свободное смешивание») этого языка с Java дает возможность писать на Scala Android-приложения. Кроме того, возможность компиляции в JavaScript позволяет разрабатывать веб-приложения на Scala.

Несмотря на некоторую схожесть и даже родственную связь этого языка с Java, целых 10 лет после появления Scala его «старший брат» хранил верность объектно-ориентированной парадигме. И только в 2014 году в Java 8 были включены элементы функционального подхода – лямбда-выражения.

Помимо упомянутых выше Java и C#, на Scala оказали влияние другие языки и технологии. Способ выражения свойств во многом заимствован из Sather. Из Smalltalk перекочевала концепция унифицированной объектной модели. Beta поделился идеей о вложенности всего подряд, включая классы. Абстрактные типы в Scala напоминают абстрактные типы сигнатур в SML и OCaml, обобщенные в контексте полноценных компонентов.

Кроме того, Scala перенял особенности таких функциональных языков, как Scheme, Standard ML и Haskell.

Целевая аудитория

Преимущества Scala оценили многие крупные компании – Twitter, LinkedIn, Foursquare, Novell, Siemens, GridGain. Однако в академических кругах это язык пока популярен больше.

Пользователь @platoff в статье достаточно подробно изложил свой взгляд по поводу целевой аудитории языка.

Я прекрасно понимаю, чем Scala привлекает неопытную молодежь (а она в основном и хочет Scala):

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

• Сложностью: наверно многие из Scala-фанатов и любителей не осознают, да и не способны сформулировать, что их привлекает в сложности. Подсознательно кто-то думает, что сложность == мощь. Типа чем сложнее, тем мощнее.

Очень сложную задачу можно просто решить, переиспользуя сложные решения. В нашем случае компилятор должен брать на себя как можно больше сложности, упрощая решение. Компилятор Scala безусловно сложен, но есть проблема — язык, в котором эта сложность выражается. Пользоваться таким языком безумно сложно.

Ngoc Dao, создатель Xitrum Scala web framework, Ngoc-Dao смотрит на ситуацию с точки зрения функционального подхода:

Говоря о функциональном подходе в принципе, безотносительно Scala, на ум обычно приходит Haskell. Однако, рассуждая с практической точки зрения, лучше выучить Erlang. Не зря все-таки Facebook потратил $19 миллиардов на покупку WhatsApp, который написан как раз на нем.

Erlang сдвинет ваше мышление в сторону функционального подхода сильнее, чем Scala. Кроме того, Erlang намного проще и быстрее учить. Вы можете освоить его за неделю и сэкономить свое время.

Так что, мнение на счет универсальности Scala может быть и скептическим – ни два, ни полтора: функциональная парадигма реализована непросто, да и в плане «объектноориентированности» он тоже слишком сложен.

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

Рейтинги и индексы

Индекс TIOBE по итогам октября 2016 года показывает, что Java является самым популярным языком программирования. Он уверенно лидирует уже 15 лет подряд и был на втором месте только в 2001 году.

Между Java и Scala в этом рейтинге наблюдается большой разрыв. Впрочем, последний уступает также языкам Lua, Fortran, Lisp, Transact-SQL, Ada и F#, расположившись на 33 месте. Однако в рейтинге 50 мест, и Scala все-таки сумел обойти функционально-логические языки Haskell и Prologue.

В другом рейтинге у Scala дела не так плохи. Согласно данным IEEE Spectrum за 2016 год, он занимает 15 место. Java тоже находится в лидерах, но на этот раз на почетном втором месте. Составители рейтинга указывают, что область применения Scala у них ограничена только веб- и мобильной разработкой. Разработка для ПК во внимание не принимается. В то время как Java они воспринимают как язык разработки для всех трех платформ.

По данным опроса Github на начало 2016 года, у Scala дела идут еще лучше: он занимает 11 место. Java опять возглавляет рейтинг. Причем, здесь он идет с большим отрывом от C#.

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

В первой группе мы видим Swift и Scala, которые делят между собой звание «идеального языка»; еще можно отметить довольно высокую оценку Go. Java здесь занимает только четвертую строчку. Это первый показатель, по которому Scala смог обойти своих родственников – C# и Java.

Перспективы

Свое мнение о будущем Scala уже высказывал Барух Садогурский — Developer advocate в компании JFrog:

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

Мы также видим другие библиотеки, которые были очень ориентированы на Scala. Например, Spark, где в новом релизе Java API подтянуты до уровня Scala, и, похоже на то, что дальше они будут развиваться не хуже API Scala, если даже не лучше. Я бы сказал, что в глобальной картине мы видим некоторый разворот в сторону Java.

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

Именно поэтому я никогда не был большим фанатом Scala, и тенденция ухода от Scala меня не удивляет. Безусловно Scala никуда не денется и продолжит развиваться, но в гораздо более нишевом формате.

Намного оптимистичнее смотрит на это Ashesh Ambasta, Lead backend engineer в CentralApp:

Я верю, что у Scala все-таки хорошие перпективы. Недаром многие крупные компании выбрали его. Несмотря на то, что путь, сочетающий ООП и ФП может показаться опасным и сбить с толку «пуритан», при аккуратном использовании, программирование на Scala может доставлять удовольствие.

Я не согласен с тем, что Scala в освоении труднее других языков программирования. Есть, конечно, определенный «барьер», связанный с необходимостью думать одновременно в разных парадигмах. Хотя на большинстве форумов этот язык почему-то обсуждают в контексте функционального программирования.

Мне приходилось слышать высказывания по типу: «Scala больше подходит для крупномасштабных систем, а не каких-то там Твиттеров». Но будет ошибкой полагать, что он создан только для этого. Я не думаю, что реализовать MVP (Minimum Viable Product) на Scala сложнее, чем на каком-то другом языке.

Я никогда не был особенно увлечен объектно-ориентированным программированием. С тех пор, как познакомился с Erlang, я к нему не возвращался. Затем я выбрал Scala для бэкэнд-разработки в новой компании и получил положительные отзывы. Это вселило в меня уверенность, что я сделал правильный выбор.

Куда пойти учиться?

Для тех, кто задумывается о смене специализации или еще только начинает карьеру программиста, приведу несколько реплик с «Тостера».

HaruAtari:

Много лет пишу на php, надоело. Сейчас переучиваюсь на Scala-разработчика. Пока все идет хорошо, язык замечательный. Плюс совместимость с Java-библиотеками.

Но сегодня зашел на hh.ru и из любопытства посмотрел количество вакансий для Java/Scala-разрабов. Scala – 47, Java — 705. После этого несколько задумался. А я вообще смогу работу найти на этом языке? Есть ли какие-то перспективы в изучении Scala как основного языка сейчас. Есть ли перспективы в таком вложении сил? Или только java?

jkotkot:

Разработчик Scala без знания Java никому не нужен. Если вы не будете понимать, как устроены и работают разные открытые Java-библиотеки, то вы никогда не станете всем нужным профессионалом в этой области.

opium:

Для России Scala в ближайшие годы — мертвый рынок, надо смотреть либо на зарубежный фриланс, либо на вакансии за границей.

gurinderu:

Что вы так сильно огорчились? Scala-разработчиков в разы меньше, чем Java, поэтому и разброс такой. Будет она востребована однозначно. К примеру, Tinkoff-банк использует Scala.

mrRontgen:

Отсутствие 100500 вакансий на hh – это не повод для паники. Язык молодой, но он очень стремительно набирает обороты. Насколько я знаю, Huawei начинают пилить интеграционные решения в России на Scala (вместо оракловских продуктов). Так что все не так плохо.

У Одерского и компании очень большие перспективы и амбиции. Так что, по моему мнению, Scala (или ее «апдейты») еще удивят программистов!

Зачем человеку Scala? / Блог компании Издательский дом «Питер» / Хабр

Здравствуйте, коллеги.

Не так давно мы допечатали книгу Одерски, Спуна и Веннерса о Scala 2.12. Ведь до Scala 3 еще далеко.

Автор сегодняшней статьи — Адам Уорски, сооснователь компании «SoftwareMill» и опытный Scala-разработчик. У него получилось интересное резюме сильных сторон современного языка Scala, которое мы и предлагаем вашему вниманию.

После пленарной лекции Мартина Одерски на ScalaDays, где он изложил планы на Scala 3 и пленарной лекции Джона де Гоуса на конференции Scalapeño о будущем Scala в сообществе Scala продолжаются оживленные дискуссии. Не считая обсуждения этих пленарных выступлений, многочисленные дискуссии идут в twitter, в сообществах Slack, а также на reddit (см. напр. 1, 2).

Вот в чем вопрос!

Все это очень интересно и познавательно для специалистов, уже работающих в экосистеме Scala. Однако, значительная часть споров связана с различными интуитивно ощутимыми или фактическими недостатками Scala как языка. Эти моменты могут отпугивать людей «со стороны», вызывая у них вопросы: «А зачем мне вообще пользоваться Scala?», «А вдруг это тупиковый путь?», «Повторит ли Scala 3 успех Python 3?» и т.д. Как и в большинстве дискуссий, внимание приковывают самые слабые и эмоциональные тезисы, и эти дебаты — не исключение.

Поэтому сделаем шаг назад: зачем вам вообще мог бы потребоваться язык Scala? Каковы технические и деловые доводы в пользу работы с эти языком?

Предметная область проекта

Начнем с того, что язык Scala особенно хорош для определенных предметных областей (но не для всех!). Важнейшее достоинство Scala – это гибкость при определении абстракций. В вашем распоряжении – ряд простейших «кирпичиков» для этого; иногда определить абстракцию не сложнее, чем использовать класс, методы и лямбда-выражения. Иногда приходится использовать неявный параметр или метод расширения; в редких случаях остается только прибегать к макрокомандам. Однако, есть варианты.

Таким образом, Scala отлично вам подойдет, если требуется сориентироваться в сложной предметной области. Например, речь может идти о распределенном или конкурентном программировании. Наладить параллелизм очень сложно, а в Scala есть ряд библиотек, упрощающих эту задачу путем построения абстракций. Для этого существует два основных подхода: акторный, реализуемый при помощи Akka, и в духе FP, представленный Monix/cats-effect и Scalaz/ZIO (если бы вы хотели подробнее почитать о сравнении этих инструментов – я написал серию статей как раз на эту тему).

Однако, разумеется, речь может идти и о других предметных областях. Возможности Scala также позволяют вывести на новый уровень моделирование типичных бизнес-приложений. Но в данном случае речь уже о сложности другого порядка. В случае с распределенными системами мы сталкиваемся с технической сложностью. При программировании бизнес-логики в приложениях речь идет уже о сложности предметной области как таковой. Например, в книге Дебасиша Гхоша (Debasish Ghosh) “Functional and reactive domain modeling” объясняется, как совместить DDD с функциональным и реактивным программированием.

Сложность языка

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

Как упоминалось выше, в Scala есть ряд базовых конструкций, из которых можно собирать абстракции. Однако, все их можно комбинировать друг с другом, благодаря чему язык и приобретает такую гибкость. Большинство новаторских проектов, которые могут вам попадаться, сводятся к тем или иным сочетаниям типов высшего порядка, неявных параметров и выделения подтипов.

Таким образом, при относительно небольшом количестве базовых возможностей (по размеру грамматики Scala проще Kotlin, Java или Swift!) — что, в свою очередь, облегчает обучение – варианты комбинаций гораздо многочисленнее.

Не слишком ли широкий выбор? Не думаю. Программист, как компетентный и ответственный профессионал, более чем в состоянии выбрать наилучший вариант, чтобы решить конкретную задачу. Подробнее об этом см. в статье “Простой стек Scala”.

Java, только лучше

Сейчас много говорят, что Kotlin вытеснил Scala в качестве “как Java, только лучше”. Но я считаю, что именно Scala, а не Kotlin, по-прежнему заслуживает такого звания. На то есть две основные причины:

Во-первых, неизменяемость в языке Scala первостепенна. Это связано с природой Scala как таковой: писать на нем код удобно прежде всего при помощи неизменяемых данных. К таким данным относятся, в частности: val (как единицы первого класса), case-классы, функции высшего порядка, т.д. Но дело и в том, как спроектирована и написана стандартная библиотека языка Scala; неизменяемы все структуры данных, используемые «по умолчанию». Благодаря неизменяемости упрощается целый ряд вещей, особенно в нашем мире высокой конкуренции, где выигрывают именно те языки, где предпочитается неизменяемость.

Во-вторых, в Scala поддерживаются конструкторы типов, типы высшего порядка и типы классов (объявляемые неявно), что серьезно упрощает работу с оборачивающими/контейнерными типами, например, с Promise, Future или Task. Такие обертки преобладают при программировании в асинхронном или реактивном стиле, и наличие языковых конструкций, упрощающих работу, скажем, с такой базой кода, где активно используются Future – еще один аргумент в пользу Scala.

Что такое типы классов? Роль их примерно такова, как у паттернов проектирования в Java, однако, они более гибкие и простые в использовании, как только вы крепко усвоите их смысл. По этому поводу есть несколько отличных руководств, например, 1, 2.

Что насчет конструкторов типов? Это такие типы как Future или Option, служащие “контейнерами” или “обертками” для других типов. Так, у вас может быть Option[String] или Future[Int]. Типы высшего порядка позволяют писать код, обеспечивающий абстрагирование любой обертки. См. например. 1, 2.

Вдруг вам интересно, зачем вообще прибегать к Future/Task? Дело не только в том, что большинство высокопроизводительных «реактивных» вычислений с минимальными задержками выполняются с применением асинхронного ввода/вывода, для которого просто просятся именно такие конструкции. Другие причины приводятся в этой дискуссии на reddit и в моей статье “Зачем возиться с обертками?”.

Работа в преимущественно неизменяемой среде, а также возможность с удобством обращаться с такими конструкциями как Future, Promise или Task (и абстрагировать их!) радикально преображает ваш код. На первый взгляд это может быть неочевидно: если у вас за плечами опыт Java или Ruby, то осознать эти аспекты Scala вы сможете не сразу. Но, даже с образовательной точки зрения полезно разобраться, как устроен «функциональный» подход и, что гораздо важнее, почему он может оказаться весьма достойной альтернативой.

Естественно, и у Scala, и у Kotlin есть ряд общих преимуществ по сравнению с Java, например:

• Более компактный синтаксис
• Меньше стереотипного кода
• Более насыщенная система типов
• Отсутствие языкового балласта

В то же время, оба языка открывают доступ к экосистеме библиотек и фреймворков JVM.

Чем насыщеннее система типов (в Scala она богаче, чем в Kotlin, а в Kotlin – богаче чем в Java), тем больше работы по верификации выполняется компилятором, а не человеком. Именно для этого и созданы компьютеры: выполнять скучные, рутинные повторяющиеся задачи. Проверка применимости типов – определенно, как раз одна из таких задач.

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

ФП vs OOП

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

ФП – это программирование при помощи функций, правда, не любых, а референциально прозрачных (см. этот ответ на reddit в более раннем треде, где превосходно объясняется референциальная прозрачность). В ООП коммуникация с объектами организована при помощи “сообщений” или, в нашей терминологии, вызовов виртуальных методов. Нет ни одной причины, по которой два этих подхода не могли бы сосуществовать, и Scala это уже продемонстрировал!

В твите о достоинствах Scala Джон де Гоус упоминает некоторые черты ООП, полезные и при чисто функциональном подходе, в частности, модули первого класса (получаемые путем композиции объектов), точечный синтаксис (вызов методов в объектах) и классы/экземпляры типов как конструкции первого класса. Все это – элементы успешной комбинации двух парадигм. Может быть, еще какие-то не за горами?

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

Scala 3

Scala 3 выйдет через два года. В нем появится ряд интересных возможностей, в частности, непрозрачные типы, параметры типажей, новый подход, связанный с метапрограммированием, типы объединения и & пересечения, неявные типы функций – вот всего несколько примеров. Конечно, здесь возникает (обоснованная) обеспокоенность по поводу миграции.

Уже известно, что будет представлен специальный инструмент для автоматической миграции кода со Scala 2 на Scala 3 при помощи scalafix. Поскольку Scala – статически типизированный язык, такая задача решаема в больших масштабах и гораздо проще, чем, например, на Python. Но, разумеется, никакой магии тут нет: даже если этот инструмент на 99% обеспечит правильное покрытие кода, все равно останется 1% наиболее проблемных случаев. Поскольку на магию рассчитывать не приходится, миграцию этих фрагментов нужно будет выполнить вручную.

Таковы издержки работы с активно развивающимся языком: вы получаете новейшие возможности, но некоторые из них на поверку оказываются не столь хороши и нуждаются в доработке. Даже с учетом этого, предлагаемые изменения не являются революционными. Язык Scala 3 очень похож на Scala 2, никаких серьезных изменений парадигмы не предвидится.

Обнадеживает тот факт, что команда Scala всерьез подходит к миграции. Тогда как ранее миграция между старшими версиями Scala (напр. с 2.8 на 2.9) была довольно обременительна, последние миграции прошли гораздо лучше. В них участвуют три основных стороны: EPFL, ScalaCenter и Lightbend все они (зачастую вместе) работают на облегчение миграции. Например, существует двоично-совместимый инструмент MIMA, а также в сообществе постоянно создаются многочисленные новые библиотеки, призванные обеспечить удобную работу с новыми версиями Scala.

Наконец, пока не законченный инструмент TASTY (который, соответственно, пока нельзя оценить) должен обеспечить использование двоичных файлов из Scala 2 в Scala 3.

Итак, зачем же использовать Scala?

Итак, каковы же причины остановиться на Scala, если рассматривать этот язык с точки зрения бизнеса? Все вышеперечисленные технические преимущества напрямую полезны и для бизнеса. Когда у вас есть язык, на котором можно писать сложный код с меньшим количеством багов – то вам обеспечены и минимальные задержки сроков, и довольные пользователи. Если вы станете писать на Scala мощные, практически не пробуксовывающие конкурентные приложения, для которых в Scala предусмотрены специальные инструментарии, то это обернется серьезной выгодой для вашей компании.

Кроме того, не забываем и о Spark, ведущей платформе для распределенного анализа данных. Scala используется не только для реализации Spark как такового, но и для определения самих вычислений. Вот вам еще одна data science-ориентированная абстракция, скрывающая сложную вычислительную модель.

Резюме

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

Scala позволяет вам развивать свой стиль программирования, каким бы языком вы раньше ни занимались: Java, Ruby или только пробуете себя в программировании. Не существует однозначно выигрышного подхода к Scala; можно придерживаться или более императивного подхода Akka, или более функционального подхода Cats и Scalaz.

Вот где можно усмотреть проблему: в сообществе Scala есть фракции, придерживающиеся “реактивного”, “синтетического” OOП/ФП подхода и чистого ФП. Однако, на самом деле в этом заключается огромное преимущество. Благодаря такому разнообразию ведутся дискуссии, высказывается множество различных мнений с разных точек зрения. На этом, в свою очередь, отлично можно выучиться нестандартному решению задач и обогатить собственный инструментарий.

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

Scala (язык программирования) — это… Что такое Scala (язык программирования)?

У этого термина существуют и другие значения, см. Scala.

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

Первые версии языка созданы в 2003 году коллективом лаборатории методов программирования Федеральной политехнической школы Лозанны под руководством Мартина Одерского (англ. Martin Odersky), язык реализован для платформ Java и .Net. По мнению Джеймса Стрэчена (англ. James Strachan (programmer)), создателя языка программирования Groovy, Scala может стать преемником языка Java^[2].

История

Язык был создан в 2001—2004 годах в Лаборатории методов программирования EPFL. Он стал результатом исследований, направленных на разработку улучшенной языковой поддержки компонентного ПО. За основу при разработке языка были взяты 2 идеи:

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

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

Истоки дизайна

На дизайн Scala оказали влияние многие языки и исследовательские работы. Следующее перечисление включает часть работ.

Scala впитала значительное число концепций и синтаксических соглашений Java и C#. Способ выражения свойств во многом заимствован из Sather (англ.). Из Smalltalk взята концепция унифицированной объектной модели. Из BETA пришла идея, что всё, включая классы, должно допускать вложенность. Абстрактные типы в Scala очень похожи на абстрактные типы сигнатур в SML и OCaml, обобщённые в контексте полноценных компонентов. В некотором смысле Scala — это продолжение работы Pizza (англ.). Как и Pizza, Scala компилируется под Java VM, добавляя функции высшего порядка, сопоставление с образцом, конструкции, которые исходно были созданы в сообществе функционального программирования. В то время как Pizza обратно совместима с Java, цель Scala — всего лишь возможность взаимодействия, так что у неё больше степеней свободы в дизайне. Ещё одна цель Scala — предоставить расширенные конструкции для абстракции и композиции компонентов — общая с несколькими недавними исследовательскими разработками.

Ключевые аспекты языка

• Scala-программы во многом похожи на Java-программы, и могут свободно взаимодействовать с Java-кодом.
• Scala включает единообразную объектную модель — в том смысле, что любое значение является объектом, а любая операция — вызовом метода.
• Scala — это также функциональный язык в том смысле, что функции — это полноправные значения.
• В Scala включены мощные и единообразные концепции абстракций как для типов, так и для значений.
• Она содержит гибкие симметричные конструкции примесей для композиции классов и trait-ов.
• Она позволяет производить декомпозицию объектов путем сравнения с образцом.
• Образцы и выражения были обобщены для поддержки естественной обработки XML-документов.
• В целом, эти конструкции позволяют легко выражать самостоятельные компоненты, использующие библиотеки Scala, не пользуясь специальными языковыми конструкциями.
• Scala допускает внешние расширения компонентов с использованием видов (views)
• Есть поддержка структурных и экзистенциальных типов.
• На текущий момент Scala реализована на платформах Java и .NET.

Объектно-ориентированный язык

В Scala используется чистая объектно-ориентированная модель, похожая на применяемую в Smalltalk: каждое значение — это объект, и каждая операция — это отправка сообщения. Например, сложение x+y интерпретируется как x.+(y), то есть как вызов метода + с аргументом x в качестве объекта-приёмника и y в качестве аргумента метода. Рассмотрим другой пример: 1+2. Это выражение интерпретируется как (1).+(2).Обратите внимание, что скобки вокруг чисел обязательны, потому что лексический анализатор Scala разбивает выражение на лексемы по принципу самого длинного возможного сопоставления. Таким образом, выражение 1.+(2) разобьется на лексемы 1.,+ и 2, потому что лексема 1. длиннее лексемы 1 и первый аргумент сложения будет интерпретирован, как тип Double вместо Int.^[3]

Функциональный язык

Каждая функция — это значение. Язык предоставляет легковесный синтаксис для определения анонимных и карринговых функций. Каждая конструкция возвращает значение. Сопоставление с образцом естественно расширяется к обработке XML c помощью регулярных выражений.

Повторное использование и адаптация

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

Scala представляет новую концепцию решения проблемы внешней расширяемости — виды (views). Они позволяют расширять класс новыми членами и trait-ами. Виды в Scala переводят в объектно-ориентированное представление используемые в Haskell классы типов. В отличие от классов типов, область видимости видов можно контролировать, причем в разных частях программы могут сосуществовать параллельные виды.

.Net и JVM

.Net и JVM во многом схожи — в том, что они оба поддерживают одиночное наследование классов, множественную реализацию интерфейсов, самоописываемые типы, ленивую загрузку типов. Хотя Scala и разрабатывалась с оглядкой на Java, ставилась также задача поддержки всех возможностей .NET.

Примеры программ

Программа, как и в Java, представляет собой объект. Это пример консольной программы, которая выводит строчку текста на экран.

 object HelloWorld {
  def main(args: Array[String]) =
    Console.println("Привет, МИР!")
 }

Следующий простой пример программы написан на Java и Scala, демонстрирующий некоторые различия в синтаксисе (постфиксная запись типов переменных, отсутствие специального синтаксиса для доступа к массивам). В этом примере описывается консольная программа, которая выводит все опции, переданные через командную строку. Опции начинаются с символа «-» (минус).

 class PrintOptions
 {
    public static void main(String[] args)
    {
      System.out.println("Выбраны опции:");
      for (String arg: args) if (arg.startsWith("-")) System.out.println(" " + arg.substring(1));
    }
 }

 object PrintOptions
 {
   def main(args: Array[String]) : Unit =
   {
     println("Выбраны опции:")
     for (arg <- args if arg startsWith "-") println(" " + (arg substring 1))
   }
 }

 // Или в функциональном стиле:
 object PrintOptions
 {
   def main(args: Array[String]) : Unit =
     println("Выбраны опции:" +: (args withFilter (_ startsWith "-") map (" " + _.drop(1))) mkString "\n")
 }

Обратите внимание, что в Scala объявляется не класс объекта, а сразу экземпляр объекта. Так естественным способом реализуется шаблон проектирования, где в программе должен быть только один экземпляр класса («Одиночка» — «Singleton»).

Пример программы, которая суммирует все элементы списка, который передаётся через аргументы.

 object Main {
   def main(args: Array[String]) {
     try {
       val elems = args map Integer.parseInt
       println("Сумма аргументов: " + elems.foldRight(0) (_ + _))
     } catch {
       case e: NumberFormatException =>
         println("Ошибка в аргументах. Использовать следует так: scala Main <число1> <число2> ... ")
     }
   }
 }

С помощью метода map перебираются все аргументы. Все они преобразовываются в целое число методом Integer.parseInt и добавляются в список (массив) elems. Затем с помощью метода свёртки списка foldRight вычисляется сумма элементов.

Интеграция с Java

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

Пример

Задача: получить и отформатировать текущую дату в локализации определённой страны, например — Франции.

В библиотеке классов Java уже есть требующаяся нам функциональность в классах Date и DateFormat. Для того, чтобы воспользоваться этим, достаточно просто импортировать эти классы из соответствующих Java-пакетов:

 import java.util.{Date, Locale}
 import java.text.DateFormat
 import java.text.DateFormat._
 
 object FrenchDate {
   def main(args: Array[String]) {
     val now = new Date
     val df = getDateInstance(LONG, Locale.FRANCE)
     println(df format now)
   }
 }

См. также

Примечания

Ссылки

Scala (язык программирования) — Национальная библиотека им. Н. Э. Баумана

Материал из Национальной библиотеки им. Н. Э. Баумана
Последнее изменение этой страницы: 13:29, 29 декабря 2016.

Scala — (произносится skaɪl) мультипарадигмальный язык программирования, сочетающий возможности функционального и объектно-ориентированного программирования^[1].

История

Язык был создан в 2001—2004 годах в Лаборатории методов программирования EPFL. Он стал результатом исследований, направленных на разработку улучшенной языковой поддержки компонентного ПО. За основу при разработке языка были взяты 2 идеи:

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

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

Объектно-ориентированный язык

В Scala используется чистая объектно-ориентированная модель, похожая на применяемую в Smalltalk: каждое значение — это объект, и каждая операция — это отправка сообщения. Например, сложение x+y{\displaystyle x+y} интерпретируется как x.+(y){\displaystyle x.+(y)}, то есть как вызов метода + с аргументом y и x в качестве объекта-приёмника. Рассмотрим другой пример: 1+2{\displaystyle 1+2}. Это выражение интерпретируется как (1).+(2){\displaystyle (1).+(2)}.Обратите внимание, что скобки вокруг чисел обязательны, потому что лексический анализатор Scala разбивает выражение на лексемы по принципу самого длинного возможного сопоставления. Таким образом, выражение 1.+(2){\displaystyle 1.+(2)} разобьется на лексемы 1.{\displaystyle 1.},+{\displaystyle +} и 2{\displaystyle 2}, потому что лексема 1. длиннее лексемы 1 и первый аргумент сложения будет интерпретирован, как тип Double вместо Int.

Функциональный язык

Каждая функция — это значение. Язык предоставляет легковесный синтаксис для определения анонимных и карринговых функций. Каждая конструкция возвращает значение. Сопоставление с образцом естественно расширяется к обработке XML c помощью регулярных выражений.

Интеграция

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

Классы и объекты в Scala могут наследовать от Java-классов и реализовать Java-интерфейсы. Это позволяет использовать Scala-код во фреймворке Java. Например, Scala-класс мог бы реализовывать интерфейс java.util.EventListener. Экземпляры этого класса затем можно оповещать о событиях, поступающих от Java-кода.

Особенности языка

Пример № 1

В качестве первого пример мы возьмём стандартную программу Hello World.

object HelloWorld 
{
   def main(args: Array[String]) 
   {
      println("Hello, world!")
   }
}

Структура такой программы состоит из main-метода, который получает аргументы командной строки в виде массива строк в качестве параметров. Тело метода состоит из единственного метода println, в качестве аргумента которому передаётся «Hello, World!». Метод main ничего не возвращает, поэтому нет необходимости явно указывать тип возвращаемых данных. Слово object обозначает то, что обычно называют синглетоном (singleton) — это класс, объект которого может существовать лишь в одном экземпляре. Такое обозначение определяет сразу и класс HelloWorld и объект этого класса, который тоже называется HelloWorld. Этот объект будет создаваться по первому требованию, в момент первого его использования. main не объявлен как static. Это потому, что в Scala нет статических членов (методов или полей класса). Вместо определения статических членов, Scala программист объявит их в синглтон объектах.

Всё является объектами

В Scala всё является объектами, включая числа или функции. Этим Scala отличается от Java, поскольку в Java разделены примитивные типа (например boolean или int) и ссылочные типы, а также нет возможности работать с функциями как со значением.
Числа – это объекты
Поскольку числа являются объектами, они также имеют методы. На самом деле, следующее арифметическое выражение:

1+2∗3/x{\displaystyle 1+2*3/x}

состоит исключительно из вызовов методов и эквиваленто следующему выражению:

(1).+(((2).∗(3))./(x)){\displaystyle (1).+(((2).*(3))./(x))}

Это также означает, что символы +, * – валидные идентификаторы в Scala. Скобки вокруг чисел необходимы, поскольку лексический анализатор Scala использует наиболее длинное правило сопоставления для токенов. То есть разобьёт следующие выражение

1.+(2){\displaystyle 1.+(2)}

на токены 1., +, и 2. Дело в том, что 1. (цифра один с точкой) более длинное совпадение, чем 1 (просто цифра один) . Токен 1. интерпретируются как литерал 1.0, в результате получается Double вместо Int. Другими словами, если мы запишем выражение как

(1).+(2){\displaystyle (1).+(2)}

то никто не подумает, что 1 это Double.
В Scala функции также являются объектами. Тем не менее, в Scala функцию можно передавать как аргумент, сохранять в качестве переменной или возвращать из другой функции. Такая возможность манипулировать функциями также, как обычными переменными является краеугольными камнем очень интересной парадигмы программирования — функциональное программирование.

Классы

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

class Complex(real:Double, imaginary:Double) 
{
   def re() = real
   def im() = imaginary
}

Этот класс может принимать два аргумента, которые являются действительной и мнимой частью комплексного числа. Эти аргументы должны быть переданы при создании объектов класса Complex: new Complex(1.5, 2.3). Этот класс содержит два метода re и im для получения этих двух частей.
Следует отметить, что тип возвращаемого значения этих двух методов задан неявно. Он будет автоматически определён компилятором, который рассмотрит правую часть этих методов и решит что в обоих случаях тип возвращаемого значения будет Double.

Методы без аргументов

Небольшая проблема методов re и im заключается в том, что для того, чтобы вызвать их необходимо указывать пару пустых скобок после имени метода, как например в следующем примере:

object ComplexNumbers 
{
   def main(args: Array[String]) 
   {
       val c = new Complex(1.2, 3.4)
       println("imaginary part: " + c.im())
   }
}

Было бы лучше иметь возможность получить доступ к действительной и мнимой части, как если бы они были обычными полями и не указывать пару пустых скобок. Это вполне выполнимо в Scala, просто определяя метод без аргументов. Такие методы отличаются от методов с нулевым количество аргументов тем, что не нужно писать скобки после их имени, ни при определение, ни при использовании. Итак, наш класс Complex может быть переписан следующим образом:

class Complex(real: Double, imaginary: Double) 
{
    def re = real
    def im = imaginary
}

Наследование и переопределение

Все классы в Scala наследуются от суперкласса. Когда суперкласс не указан, как например в предыдущей главе в примере Complex, то будет по-умолчанию использоваться класс scala.AnyRef.
Также можно переопределить (override) метод наследованный в суперклассе. В Scala существует требование явно указывать модификатор override, для того чтобы избежать случайное переопределение. В нашем примере, класс Complex может быть дополнен методом toString переопределяющим его из Object^[2].

class Complex(real: Double, imaginary: Double) 
{
    def re = real
    def im = imaginary
    override def toString() = "" + re + (if (im < 0) "" else "+") + im + "i"
}

Примечания

1. ↑ Scala [Электронный ресурс] : Материал из Википедии — свободной энциклопедии: — Режим доступа: https://ru.wikipedia.org/wiki/Scala
2. ↑ Учебное пособие по Scala. Вольный перевод. [Электронный ресурс]: Режим доступа: http://programador.ru/scala-tu/

Что нужно знать Scala-разработчику? Все для Scala Developer

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

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

У Scala лаконичный синтаксис, позволяющий четко выразить мысль. Несмотря на статическую типизацию, в большинстве случаев указывать тип переменной не нужно – поможет компилятор. Если имя переменной не важно, либо понятно из контекста – его можно не указывать. Вот пример.

case class User(firstName:String, lastName:String)

Seq(12.2, 32.43, 233.2).filter(_ < 100).reduce(_ + _) // 44.63

У SDK огромное количество функций Out-of-the box

Многие базовые операции, которые в других языках пришлось бы реализовывать в каждом проекте с нуля, есть в SDK. Например, у объекта String доступно 100 + методов.

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

(1 to 1000000000000).view.filter(_ % 2 != 0).take(50).toList // Из-за «ленивости» не вызовет OutOfMemoryError

Широкое использование принципов функционального программирования.

type ErrorDto = String

def tryParse(input:String) = Try(input.toDouble).map(Right(_)).getOrElse(Left(s»Make sure $input is a number»))

lazy val result: Either[ErrorDto, Double] = tryParse(“23.23”)

Где можно применить Scala?

Scala на уровне языка поддерживает ленивые, параллельные и асинхронные вычисления, поэтому популярна при разработке приложений по распределенной обработке данных. Это один из четырех языков Big Data вместе с Java, Python и R. Big Data продукты, такие как Apache Spark, Apache Flink и Apache Kafka написаны на Scala и используют многие ее концепции. Apache Spark работает до 10 раз быстрее со Scala, чем с Python.

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

Scala в мире Java-разработки

Scala – один из JVM языков. Следовательно, знания Java и Kotlin помогут быстрее изучить Scala. Обратное также справедливо. Многие возможности, которые постепенно добавляются в Java начиная с 8-ой версии, были доступны в Scala раньше. Это касается Stream API, REPL, Interfaces with Implementation и var. Не все укоренились на Java-проектах.

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

Что нужно знать Scala-разработчику?

Scala – объектно-ориентированный язык и тесно связан с Java. Знания ООП и паттернов программирования очень важны.

Scala – функциональный язык, и в этой парадигме многие его преимущества. Хороший Scala-разработчик каждый день пишет приложения с неизменяемыми структурами данных, без переменных, с использованием функций высших порядков, монад и функторов. Нужно понимать многопоточность и связанные с ней издержки. Многие приложения строят многопоточность на модели акторов, реализованной в библиотеке Akka. Хороший код на Scala всегда конкурентный, без блокировок и зачастую выполняется параллельно. Также нужно знать и уметь работать с хранилищами данных: PostgreSQL, Apache Cassandra и MongoDB.

Scala будет актуальна в 2020 году?

В области распределенных вычислений и высоконагруженных приложенийя Scala на острие IT. Рост объемов обрабатываемой информации будет требовать применения подобных решений еще сильнее. Scala используют в динамично развивающихся проектах в комбинации с Python и Java. Функциональные подходы Scala к написанию кода так же помогут быстрее разобраться с Kotlin, Haskell, Elixir или Closure.

Где можно изучить Scala?

iTechArt приглашает студентов профильных специальностей на двухмесячную стажировку Scala в Students Lab. Мы проводим лекции и практические занятия по реляционным и нереляционным базам данных, архитектуре web-приложений и созданию RESTful сервисов. В конце стажировки студенты разработают RESTful сервис, моделирующий предметную область с помощью актуального стэка технологий.

Вот, что узнают участники Students Lab:

Основы синтаксиса Scala и функционального программирования.

Play 2 – один из самых популярных Web-фрэймворков на Scala и Java.

Akka – мощное средство для построения высоконагруженных приложений.

Slick – одна из самых популярных библиотек типа ORM/FRM для работы с базами данных в экосистеме Scala.

PostgreSQL – топовая реляционная база данных.

Docker – средство контейнеризации приложений.

Чтобы пройти отбор в Scala Students Lab, покликайте на ссылки ниже. Вместе со Scala-разработчиками из iTechArt собрали гайды по изучению Scala. Сохраняйте материал в закладки, мы будем обновлять библиотеку полезных ссылок.

• Введение в модель конкурентных вычислений, построенную на акторах: https://doc.akka.io/docs/akka/current/typed/guide/actors-intro.html
• Модель акторов: https://www.brianstorti.com/the-actor-model/
• Обзор преимуществ модели акторов, по сравнению со стандартными подходами: https://doc.akka.io/docs/akka/current/typed/guide/actors-motivation.html

OMG Scala is a complex language! / Хабр

Я постоянно замечаю, что «О, святые небеса, Scala — это сложно!». Знаете, возможно это правда. Давайте попробуем посмотреть на эту сложность и пройтись по основным отличиям Scala от других объектно-ориентированных языков (например, Java или C++).

Вывод типов

    В большинстве случаев, компилятор способен вывести тип, что позволяет разработчикам писать меньше повторяющейся информации, которую они так привыкли писать в Java и C++.
    К примеру, совершенно ясно, что «john» это строка, так что компилятор может вывести тип самостоятельно, и мне не придется указывать тип явно. Я могу просто написать:

  val aGuy = "John"

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

Упрощенное определение классов

    Так как OOP строится на основе определения классов, то в Scala это реализовано максимально просто. Все мои доменные модели получаются предельно простыми.

class Person (val firstName:String, val lastName:String)

    Надо сказать, что тоже самое в Java или C++ заняло бы почти страницу кода со всякими там конструкторами, геттерами, сеттерами и т.д. Разработчики Scala поняли, что люди не должны писать целую страницу кода лишь ради того, чтобы сообщить глупому компилятору, что им нужен класс Person, у которого есть два поля: имя и фамилия. Так что, в Scala, определение такого класса занимает всего лишь одну строчку, так же как выглядела бы таблица в SQL.
    Добавляет ли это сложности?
    Ну… Мне нужно обеспокоится разве что в тех случаях, когда мне нужно переопределить сгенерированные геттеры и сеттеры. Так что я даже и не знаю, действительно ли это усложняет жизнь…
    Я?! Лично я настолько в восторге от этой возможности, что, честно говоря, мне абсолютно всё равно, что вы там себе думаете.

Объединение методов и операторов

    Все языки программирования, которые я знаю, проводят жесткую грань между методами с именем, типа «append», и операциями, типа «+=». Некоторые языки, запрещают переопределение существующих операторов (Java). Другия языки разрешают только инфиксную нотацию для операторов (C++). В Scala нет всех этих ограничений. Вы можете использовать любые имена для названия методов, а инфиксная нотация разрешена для любых вызовов:

ListBuffer(1,2,3) append 4

// И так тоже можно 

ListBuffer(1,2,3) += 4

    Единственное отличие будет состоять в правилах приоритетности. Конечно, кто-то скажет, что это «более сложно», чем в Java или C++, потому что это «развязывает руки» и позволяет делать всё что хочешь. Однако, я считаю, что это более просто, чем в упомянутых языках. В конце концов, это делает Scala совершенным фреймворком для создания естественного DSL:

"Mary" with "a purse" and "red shoes" should look "nice"

Типы

    И в Java и в C++ шаблоны имеют определенное зашитое ограниченное поведение (т.е. ковариантность) и позволяет только несколько конструкций (наподобие List<T extends Person>).
В Scala есть дефолтное поведение, при котором List[Person] невариантен, но всё можно настроить. Если вам нужна ковариантность, просто скажите компилятору List[+Person] или List[-Person] для контрвариации. На подобии Java, есть конструкция List[T <: Person] и List[T >: Person]. Так как в Scala есть механизм неявных преобразований (implicits), то также доступна еще одна конструкция, как раз для таких случаев: List[T <% Person].
    Сложнее ли это?
    Так же как и с операторами, этот механизм порождает некоторые ограничения, однако, с другой стороны предоставляет новые возможности. Лично мне нравится этот контроль типов. Пользовался ли я этим? Не в каждодневной разработке, чаще всего хватает обычного дефолтного поведения контроля типов.

Только конструкторы?

    Большинство языков позволяет только конструировать объекты. Scala позволяет также деконструировать объекты, при этом я не говорю об освобождении памяти, занимаемой объектом. Рассмотрим:

someone match {
  case Person(first,last) => println (s" name is $first $last")
}

    Здесь вы можете увидеть, что я подразумеваю под «деконструкцией» объекта. Возьмем уже созданный объект и деконструируем его на компоненты first и last. Я знаю, это выглядит чуждно и непривычно для большинства сторонников OO, но поверьте мне, это безумно круто и удобно! Представьте, что вам пришлось бы сделать, для того чтобы реализовать подобное в Java или C++… Проверить на тип (instanceof), присвоить две переменные на эти значения и еще много чего…
    Вспомните про интерполяцию строк в Scala:

"$first $last"

    Это более сложно? Ну… Это совершенно новый функционал. Мне нравится! Поверьте, вам тоже это понравится!

    Вот, кстати, match/case предоставляет более широкий спектр возможностей, нежели обычный switch/case, который умеет работать только с константами. С помощью match/case можно деконструировать объекты, матчить константы, матчить типы, и многое, многое другое! Да посмотрите сами:

someone match {

  case Person(first,last) => println (" name is " + first + " " + last)

  case "John" | "Mary" => println ("hello, " + someone.toString)

  case s:String => println ("name is " + s)

  case _ => println ("don’t know what this is…")

}

    Это сложно? Я не знаю… в Java или C++ это заняло бы от одной до двух страниц кода. Лично для меня, в Scala это выглядит просто и интутивно понятно.

Заключение

 Конечно, это лишь некоторые аспекты языка. Если вам есть что добавить, пишите пост, буду рад.
Я не касался функционального программирования на Scala, для этого нужно сравнивать Scala с другими функциональными языками, он я не FP’шник (FP guy). С++ сейчас позволяет передавать указатели на функции в другие функции, а в Java 8 введены lambda конструкции.

Сложно ли всё это? Ну… Можно посмотреть с двух сторон на всё это:
Да,

• Больше символов и возможностей, которые можно использовать
• Нужно учить некоторые дополнительные термины и понятия из области компьютерных наук (контравариация, паттерн матчинг, лямбды, замыкания и т.д.)

Нет,

• Реальные проблемы решить можно
• Такие же конструкции на Java или C++ сделать впринципе невозможно или это займет гораздо больше кода… и… код будет выглядеть ужасно.

    Что я думаю? Мне реально всё равно. Лично я очень рад, что познакомился с этими возможностями. Это позволяет мне решать проблемы всего лишь в несколько строчек кода, в то время как мои друзья всё еще пишут эти геттеры и сеттеры…

Негатив

    Есть всё же несколько вещей, которые мне не понравились, за чуть более чем шести летний опыт работы со Scala. Вот некоторые из них:

1. Медленная компиляция. Не то чтобы раздражающе медленная, но всё же гораздо медленнее, чем у остальных.
2. Неявные преобразования. Мне не нравится как они реализовали этот механизм. Можно случайно заимпортировать преобразование из Any в MyCoolThing, котороый был определен в каком-нибудь импортируемом блоке.
3. Библиотека коллекций. Для большинства людей это не так важно, но… Всё это выглядит гораздо сложнее, чем мне хотелось бы.
4. SBT. Это всегда сложно. Серьезно, если вам нужно сделать что-то выходящее за рамки типичной работы с SBT, то вы попали. Существует столько разных не очевидных DSL, что Google будет сходить с ума пытаясь найти для вас как нужно сделать то, что вам нужно. Им нужно было сделать либо какой-то отдельный синтаксис, наподобие JSON или какой-то свой внутренний DSL, который компилятор / IDE мог бы понимать и помогать при работе с SBT.

P.S. Более детальная дискуссия насчет сложности: Simple or Complicated?

[Конспект] Scala

Основы

Интерпретатор

Scala имеет интерпретатор командной строки REPL. По сути он не является интерпретатором, а представляет из себя программу, которая считывает введенные данные, компилирует их в байт-код JVM, выполняет и возвращяет результат. REPL — read-eval-print loop. REPL включается в себя некоторые способности командной строки, например автозавершение команд по нажатию TAB. Чтобы воспользоваться программой небходимо ввести программу scala с командной строки.

Объявление значений и переменных

Если попробовать ввести в REPL число, например, то увидим нечто похожее.

scala> 12
res0: Int = 12

REPL говорит нам, что записал 12 в значение (val) res0. Теперь можно обратиться к данному значению.

scala> res0 + 10
res1: Int = 22

Вместо имен “resN” можно использовать свои имена переменных. Если переменную объявить как val, то переменная будет значением, то есть недоступна для изменения или перезаписи. А вот если объявить как var, то это будет самая настоящая переменная с возможностью перезаписи и изменения. Если переменная была объявлена как ленивая lazy, то вычислена она будет при первом обращении к ней.

scala> val question = "Are you ready?"
question: java.lang.String = Are you ready?

scala> question = "Are you stupid?"
<console>:8: error: reassignment to val
question = "Are you stupid?"
^

scala> var answer = "Yes!"
answer: java.lang.String = Yes!

scala> answer = "No :("
answer: java.lang.String = No :(

Как можно обнаружить REPL отвечает нам как varName: varType, в Scala тип всегда указывается через через двоеточие. Можно всегда указывать явно, хотя в большинстве случаев Scala может вычислить самостоятельно.

var age: Int = 45

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

var heigth, width: Int = 10

Если возникает необходимость использовать в качестве имени переменной зарезервированное слово, то необходимо обернуть его в обратные кавычки.

scala> var `do` = 10
do: Int = 10

Часто используемые типы.

Все типы в Scala являются классами, поэтому не никакой разницы между простым типом и классом. Можно вызывать метод непостредственно у числа, например.

scala> var float = 1.toFloat
float: Float = 1.0

Можно выделить 10 “простых” типов в Scala.

• Byte — целое число от -128 до 127.
• Short — целое число от -32768 до 32767.
• Int — целое число от -2147483648 до 2147483647.
• Long — целое число от -9223372036854775808 до 9223372036854775807. Можно объявить как int с символом l в конце.
• Float — десятичное число от -3.4028235-e38 до 3.4028235+e38. Можно объявить как int с символом f в конце.
• Double — десятичное число от -1.7976931348623157+e308 до 1.7976931348623157+e308. Можно объявить как int с символом d в конце.
• Char — символ, литералами являются одинарные кавычки. Можно создать через код в виде числа int с вызовом toChar. Можно использовать код \uXXXX, \n или \t
• String — строка, простейшими литералами являются двойные кавычки. Использование:
  • " — можно использовать специальные символы переноса строки и прочих.
  • """ — многострочная строка.
  • s" или s""" — строка, в которой можно подставлять переменные через $varName, или же выражения ${1 + $varName}.
  • f" или f""" — строка, в которой можно подставлять переменные подобно функции printf через $varName%format, или же выражения ${1 + $varName}%format.
  • raw" или raw""" — строка, специальные символы будут отображены. То есть \n не перенесет строку, а так и останется \n.
  • Так же можно реализовать свои специальные литералы через implicit-классы, которые будут использовать StringContext.

Методы в Scala

Scala позволяет использовать стандартные арифметические (+, -, *, /, %) и подразрядные операции (&, |, ^, «, »). Есть лишь один аспект, по сути эти операторы являются методами. Методы в Scala можно вызвать двумя способами.

• Dot notation — через точку.
• Operator notation — для методов с одним параметром.

scala> 1.+(2)
res1: Int = 3

Домашняя страница

.

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

БЛОГ

Scala 3 — версия

от сообщества
Вторник, 15 сентября 2020 г.

После 8 лет исследований, экспериментов, испытаний, обсуждений, многочисленных вкладов ученых и сотрудников сообщества, проект Dotty наконец завершится осенью 2020 года, превратившись в Scala 3. В этом блоге рассказывается о том, что нужно для координации Scala 3 высвободить усилия и пригласить вас помочь нам добиться успеха!

Текущая ситуация?

Мы координируем около 52 проектов с участием менее 20 человек, разбросанных по нескольким организациям, и до реализации остается четыре месяца.

Категории алмазного сырья в рамках этих 52 проектов:

• Особенности языка
• Инструменты
• Миграция
• Производительность
• Документация

Дорожные карты и обновления проектов публикуются в дискуссиях авторов в разделе «Проекты выпуска Scala 3»; все больше публикуются время от времени. Присоединяйтесь к форуму, чтобы поделиться своими мыслями, идеями и узнать больше о каждом проекте.

Кто причастен к выпуску?

• Проф.Мартин Одерски и его исследовательская лаборатория (LAMP) находятся в авангарде и движущей силе разработки релизов Dotty и Scala 3. Примечание: это команда из 8 человек, которые работают не только над Дотти, но и над своими исследованиями, а также над обучением.

• Центр

  Scala, языковая основа Scala, недавно выступил в качестве основного координирующего органа для усилий по выпуску Scala 3 и выделил значительные ресурсы для разработки, обучения, коммуникации и управления проектами.Примечание. Команда Scala Center состоит из 9 человек, 5 из которых присоединились (совсем) недавно.

• Компании Консультативного совета Scala Center поддерживают выпуск Scala 3 различными способами и возможностями. Все они поделились своими советами и призвали Scala Center принять участие, а некоторые из них (например, Lightbend, VirtusLab, Lunatech, 47 Degrees) предоставили дополнительные инженерные ресурсы и повседневную логистику.

• VirtusLab поддерживает усилия, связанные с реализацией Scala3Doc и Metals (IDE поддерживает Dotty через LSP).Они также недавно участвовали в компиляторе (перенос изменений бэкэнда Scala 2 в Dotty на данный момент) и разработке и поддержке Scala Native (путь к поддержке первого Scala 2.12 и, в конечном итоге, Dotty). VirtusLab продолжит свое участие в Metals / Dotty до самого выпуска Dotty, а затем в обозримом будущем.

• Typelevel координирует свою работу со своей экосистемой, чтобы стремиться к полностью совместимым с исходным кодом, нативным для Dotty выпускам всех связанных основных проектов в рамках их текущей основной (двоично-совместимой) линии.Теоретически любые последующие приложения, полностью входящие в экосистему Typelevel, должны иметь возможность обновляться до Scala 3 так же легко, как обновляться с 2.12 до 2.13. Кроме того, Cats Effect нацелена на конец года для выпуска версии 3.0 (капитальный пересмотр его основной семантики). Этот выпуск сам по себе тесно координируется ниже по течению, а это означает, что многие проекты в экосистеме Typelevel будут выпускать два основных выпуска, совместимых со Scala 3, примерно в конце года: один для Cats Effect 2 (исходный код совместим с текущим 2.13 версий) и один для Cats Effect 3 (который также будет иметь сборки 2.12 и 2.13).

• Многие другие организации и отдельные участники, вкладывающие свое свободное время, которым мы все невероятно благодарны — ваш энтузиазм и любовь к Scala очень вдохновляют!

Где следить за развитием?

(или: достоверные источники)

Scala-lang.org
Twitter: @scala_lang и @odersky
Обсуждение авторов
Scala Center и члены команды LAMP

Чего ожидать?

Мы сталкиваемся с глобальной неопределенностью во всех сферах нашей жизни, поэтому устанавливать ожидания было бы, мягко говоря, неразумно.Однако мы намерены получить релиз-кандидата Scala 3 до конца 2020 года. Каждый вклад, доброе слово, приветствие приветствуются сейчас как никогда — и мы заранее благодарим вас за терпение!

Что я могу сделать сегодня?

Вы уже можете взглянуть на Руководство по миграции и, возможно, попробовать его или добавить / поделиться своим опытом. Если вас интересует какой-либо из проектов, представленных на форуме авторов, свяжитесь с руководителем проекта и спросите его / ее / их, как лучше использовать свое время / опыт.

.

Введение | Экскурсия по Скала

Добро пожаловать в тур

Этот тур содержит краткие сведения о наиболее часто используемых функциях.
Scala. Он предназначен для новичков в языке.

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

Что такое Scala?

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

Scala объектно-ориентированный

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

Scala работает

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

Кроме того, понятие сопоставления с образцом в Scala естественным образом распространяется на обработку XML-данных с помощью правильного игнорирования шаблонов последовательностей посредством общего расширения с помощью объектов-экстракторов.В этом контексте для понимания полезно формулировать запросы. Эти функции делают Scala идеальным для разработки приложений, таких как веб-службы.

Scala имеет статическую типизацию

Система выразительных типов

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

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

Scala расширяема

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

Во многих случаях это можно сделать без использования средств метапрограммирования, таких как макросы. Например:

Scala взаимодействует с

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

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

Наслаждайтесь туром!

Пожалуйста, перейдите на следующую страницу, чтобы узнать больше.

.

Scala Standard Library 2.13.3 — scala

Scala Standard Library 2.13.3 — scala

package scala

Элементы типа

1.  type :: [+ A] = scala.collection.immutable.::[A]
2.  запечатанный абстрактный класс <: <[- From, + To] extends (From) => To с Serializable
3.  запечатанный абстрактный класс =: = [From, To] extends <: <[From, В] с Serializable
4.  типа AbstractMethodError = java.lang.AbstractMethodError
5.  абстрактный класс Any
6.  абстрактный класс AnyVal расширяется Any
7.  trait Приложение расширяет DelayedInit
8.  final class Array [T] расширяет java.io. java.io. lang.Cloneable
9.  тип ArrayIndexOutOfBoundsException = java.lang.ArrayIndexOutOfBoundsException
10.  тип BigDecimal = scala.math.BigDecimal
11.  тип BigInt.math.BigInt
12.  абстрактный конечный класс Boolean расширяет AnyVal
13.  абстрактный конечный класс Byte расширяет AnyVal
14.  абстрактный конечный класс Char расширяет AnyVal
15.  тип ClassCastExceptionClass = java.lang.
16.  type Cloneable = java.lang.Cloneable
17.  abstract final class Double extends AnyVal
18.  final class DummyImplicit extends AnyRef
19.  trait Dynamic extends Any

 Either + A, + B] = Scala.util.Either [A, B]

20.  абстрактный класс Enumeration extends Serializable
21.  trait Equals extends Any
22.  тип Equiv [T] = scala.math.Equiv [T]
23.  type Error = java.lang.Error
24.  type Exception = java.lang.Exception
25.  abstract final class Float extends AnyVal
26.  type Fractional [T] = scala.math.Fractional [ T]
27.  trait Function0 [+ R] расширяет AnyRef
28.  trait Function1 [-T1, + R] расширяет AnyRef
29.  trait Function10 [-T1, -T2, -T3, -T4 , -T5, -T6, -T7, -T8, -T9, -T10, + R] расширяет AnyRef
30.  trait Function11 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, + R] расширяет AnyRef
31.  trait Function12 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, — T8, -T9, -T10, -T11, -T12, + R] расширяется AnyRef
32.  trait Function13 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, + R ] расширяет AnyRef
33.  trait Function14 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, + R] расширяет AnyRef
34.  trait Function15 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, — T12, -T13, -T14, -T15, + R] расширяет AnyRef
35.  trait Function16 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9 , -T10, -T11, -T12, -T13, -T14, -T15, -T16, + R] расширяет AnyRef
36.  trait Function17 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, + R] расширяет AnyRef
37.  trait Function18 [- T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, + R] расширяет AnyRef
38.  trait Function19 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, + R] расширяет AnyRef
39.  trait Function2 [-T1, — T2, + R] расширяет AnyRef
40.  trait Function20 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12 , -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, + R] расширяет AnyRef
41.  trait Function21 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21 , + R] расширяет AnyRef
42.  trait Function22 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, + R] расширяет AnyRef
43.  trait Function3 [-T1, -T2, — T3, + R] расширяет AnyRef
44.  trait Function4 [-T1, -T2, -T3, -T4, + R] расширяет AnyRef
45.  trait Function5 [-T1, -T2, -T3, — T4, -T5, + R] расширяет AnyRef
46.  trait Function6 [-T1, -T2, -T3, -T4, -T5, -T6, + R] расширяет AnyRef
47.  trait Function7 [-T1, -T2, -T3, -T4, -T5, — T6, -T7, + R] расширяет AnyRef
48.  trait Function8 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, + R] расширяет AnyRef
49.  trait Function9 [-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, + R] расширяет AnyRef
50.  type IllegalArgumentException = java.lang.IllegalArgumentException
51.  тип IndexOutOfBoundsException = java.lang.IndexOutOfBoundsException
52.  тип IndexedSeq [+ A] = scala.collection.immutable.Indexed10 902 919 919 абстрактное расширение класса AnyVdexed10 919 919
53.  type Integral [T] = scala.math.Integral [T]
54.  type InterruptedException = java.lang.InterruptedException
55.  type Iterable [+ A] = scala.collection.Iterable [A]
56.  тип IterableOnce [+ A] = scala.collection.IterableOnce [A]
57.  Тип Iterator [+ A] = scala.collection.Iterator [A]
58.  тип LazyList [+ A] = scala.collection.immutable.LazyList [A]
59.  тип Left [+ A, + B] = scala.util.Left [A, B]
60.  список типов [+ A] = scala.collection.immutable.List [A]
61.  абстрактный конечный класс Long extends AnyVal
62.  final class MatchError extends RuntimeException
63.  тип NoSuchElementException = java.util.NoSuchElementException
64.  final class NotImplementedError расширяет ошибку

.