Scala

lastmod 2024-11-06created 2015-05-0586 edits

Scala is a multi-paradigm programming language that combines elements of object-oriented programming languages and functional programming. The name Scala is pronounced <skah-lah> and comes from 'Scalable Language'. It is notable for letting you write very large systems with a small amount of code. It can run on Java's Java virtual machine, and Java APIs can be used as-is or in a slightly modified form that fits Scala's style.

Scala is a general-purpose programming language that can express patterns expressible in other languages very concisely. By combining elements of object-oriented programming languages and functional programming and applying the Java API, it helps raise programmer productivity. For example, a program with the same functionality ends up 2-3 times shorter than one written in Java.

It has good interoperability with the Java runtime environment (runtime environment (JRE)), and also provides support for .NET.

Categories

• Basics
  • val: (immutable) value. (value)
  • var: (mutable) variable. (variable)
• Unified types
• Class
• Default Parameter Values
• Named Arguments
• Trait
• Tuples
• Mixin class composition
• Higher-order functions
• Nested functions
• Currying
  • For example, defining multiple parameter lists, as in def modN(n: Int)(x: Int)= ((x % n) == 0).
• Case Classes
• Pattern Matching
  • Using @, using match and case.
• Singleton objects
• Regular expression patterns
• Extractor Objects
• For Comprehensions: for .. yield
  • Apparently also called Sequence Comprehensions
• Generic Classes
  • Declared like class Baz[A] { ... }, used like val stack = new Stack[Int].
• Variances
  • Used in generics like class Foo[+A], class Bar[-A], class Baz[A].
• Upper Type Bounds: in short, [B <: A]: B is constrained to be a subtype of A.
• Lower Type Bounds: in short, [B >: A]: B is constrained to be a supertype of A.
• Inner Classes
• Abstract types (Abstract Type Members)
• Compound Types
• Explicitly typed self-references
• Scala:Implict
  • Implict Parameters
    • implicit valintMonoid: Monoid[Int] = new Monoid[Int] { ... }
    • def sum[A](xs: List[A])(implicit m: Monoid[A]): A = ...
  • Implict Conversions
    • implicit defint2Integer(x: Int) = java.lang.Integer.valueOf(x)
• Polymorphic Methods
• Local type inference
• Operators
  • Infix operators: +, -, *, ++, etc.
  • Unary operators: unary_
• By-name Parameters
  • def calc(i: => Int) = i * 37
• Annotations
• Packages and imports
• Package objects
• Scala:Monad (Monad)
• Underscore On the uses of the underscore (_).
• ???: What is the counterpart of extends in public HashMap(Map<? extends K,? extends V> m);?
• ???:

Frameworks

package object json {

import DefaultJsonProtocol._

implicit def enrichJsonString(s: String) = new EnrichJsonString(s)

private[json] class EnrichJsonString(s: String) {
def rightJsValue: Either[AnswerError, JsValue] = Try(s.parseJson) ...
}

}

</syntaxhighlight>

More

• Scala:Lazy
• Scala:String
• Scala:Option & Scala:Either
• Scala:Future
• Scala:Apply
  • When you make a call by wrapping one or more markdown="1"> values in curly braces ({ and }), as in Future { ... }, that object's apply method is called.

  It aims to be a full stack web framework based on Scalatra. Naturally, it was influenced by Ruby on Rails. Being Full Stack, it has a ton of features. It even supports ORM… It is not my preferred type, but it looks like it could replace Play Framework.

• Higher-order function
  • Scala:Zip
  • Scala:Map
  • Scala:FlatMap
  • Scala:Collect
  • Variable arguments (vararg): vararg, _* type annotation
  • Container
    • Scala:List (scala.collection.immutable.List)
    • Scala:Concurrency - topics on concurrency in Scala.
    • Scala:Collection - Scala collections
    • Scala:Troubleshooting

    • Build tools

      • Gradle
      • Maven
      • Ant
      • Bazel
      • Mill - a fast JVM build tool for Java and Scala

      Classes

      • com.typesafe.config.ConfigFactory
      • scala.collection
        • TraversableLike
        • immutable.List
        • mutable.Builder
      • scala.util.Try

      Libraries

      • sbt
      • akka
      • spray-json
      • slick

      How to install

      • Scala - Mac OS X Setup Guide

      $ brew update
      $ brew install scala
      $ brew install sbt
      

      Hello, World!

      Create a HelloWorld.scala file as below.

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

      Compile it and then run it as below.

      $ scalac HelloWorld.scala
      $ scala -classpath . HelloWorld
      

      Regex

      • Stackoverflow - Using regex with filter in Scala

      val regex = """^([a-zA-Z]\d{6})""".r // enables you to drop escaping \'s
      val f = List("b111111").filter { s => regex.findFirstIn(s).isDefined }
      

      Elapsed Time

      • Measuring execution time (Scala, Python, Java)

        def elapsedTime[R](block: => R): (R, Long) = {
          val start = System.currentTimeMillis
          val result = block
          val end = System.currentTimeMillis
          (result, end-start)
        }
      

      Grave quotes

      • Stackoverflow - Need clarification on Scala literal identifiers (backticks)

      Using backticks, you can more or less give any name to a field identifier. In fact, you can even say

      val ` ` = 0
      

      which defines a variable with name . (one character of whitespace)

      Cake Pattern

      • (scala) self/ this and Injection (Cake Pattern)

      JDK Compatibility

      • JDK Compatibility | Scala Documentation
      • Download | The Scala Programming Language

      Frameworks

      • Web Frameworks built with the Scala language

      Play Framework 2

      Play Framework adopts the Ruby on Rails philosophy and lets you build web Applications very easily and quickly. In particular, everything can also be implemented in java, so it has a large user base. From play framework 2 onward, it uses a template engine built with scala, providing more speed and a wider range of features. In particular, the compile on changing feature using sbt applies code changes automatically and immediately, which makes building Web Applications considerably more convenient. However, as with Rails, supporting everything can be an advantage, but it can become a problem if a developer wants to use a different version of a library, and personally, sbt seems slow and ivy2's dependency management seems to have problems.

      Spray

      Spray is good for building lightweight, high-performance Web Applications specialized for REST. It uses Akka for high-performance asynchronous work. When Spray is used to serve a special purpose (REST-API), its performance is awesome! In other words, if the target is a large-scale API server, I highly recommend it. However, there is the burden of studying not only Scala and Akka but also Spray's own operators. Still, if you are truly thirsty for performance, I recommend it.

      Scalatra

      It describes itself as a web micro-framework inspired by Sinatra, which is written in Ruby. Unlike other full-frameworks, it is lightweight and flexible. It is well modularized so developers can use other kinds of libraries, and it follows existing servlet container standards well. What stands out is that with the template engine called scalate, you can use various formats. (Scaml, SSP, Jade, etc.) I see this as a considerable advantage: you can use whichever format you like and switch midway, and several people can use different formats. (Whether this is an advantage or a disadvantage may differ, but I would like to see it as an advantage.) It also supports Twirl, which was made by spinning off the Template engine provided by Play Framework 2. Like spray.io, it supports asynchronous communication using Akka, and it also supports asynchronous communication using Atmosphere. For developing a REST-API and producing its documentation, using Swagger gives very good results.

      Skinny

      It aims to be a full stack web framework based on Scalatra. Naturally, it was influenced by Ruby on Rails. Being Full Stack, it has a ton of features. It even supports ORM… It is not my preferred type, but it looks like it could replace Play Framework.

      See also

      • Java
      • JVM
      • Monad

      Favorite site

      • Wikipedia (en) description of Scala
      • Getting started with Scala
      • An introduction to Scala for Java developers

      Tutorials

      • [Recommended] Tour of Scala - Introduction
      • [Recommended] Scala School!
      • Effective Scala
      • Github - Basics of functional programming with Scala
      • [BOOK] Functional Programming for Mortals
      • Scala syntax summary (Scala Cheatsheets)
      • [Recommended] HAMA blog - Scala course (1 ) - Introduction

      Guide

      • Asynchronous Programming and Monad Transformers in Scala
      • Monad Programming with Scala Future
      • Lazy evaluation of Collections using Stream (solving the look-and-say sequence)
      • Akka gRPC Quickstart with Scala (gRPC, Scala, Akka)
      author Zer0 sitemap