reveal.js

##
						## The unique features that make Scala, Scala

Adam Warski, April 2024

<a href="https://twitter.com/adamwarski">@adamwarski</a> /
						<a href="https://softwaremill.social/@adamwarski">@softwaremill.social</a>

---

## What is Scala?

* general-purpose programming language   
						* functional
						* object-oriented
						* strongly typed

---

## What is Scala?

A programming language that scales with you: from small scripts to large multiplatform applications.

---

## Hello, world!

```scala
						@main def hello(): Unit = println("Hello, SFI!")
						```

---

## Multi-platform

* JVM: dominant
						* JS
						* Native

---

## FP + OO fusion: but what are they?

Object oriented programming

combines state and behavior: objects
interaction: message passing
behavior templates: classes
state is protected: encapsulation
relationships between classes: inheritance
abstraction: polymorphism

Functional programming

functions: input => output
first-class citizens: named, passed as arguments, returned
programming = composing (small) functions
declarative, not imperative
behavior and data are separate

There are no "best" solutions in programming

That's why we need to combine paradigms

Preferably, with low syntax & boilerplate overhead

## Data modelling

```scala [1-2|4-5|7-10]
						trait FieldOfStudy:
						  def points: Int

case object ComputerScience extends FieldOfStudy:
						  def points: Int = 42

case class Linguistics(language: Language)
						  extends FieldOfStudy:

def points: Int = 51
						```

---

```scala [1-3|5-9|11-14]
						trait Student:
						  def field: FieldOfStudy
						  def knowsAbout(subject: Subject): Boolean

case class DiligentStudent(field: FieldOfStudy,
						    knowledge: List[Book]) extends Student:

def knowsAbout(subject: Subject): Boolean =
						    knowledge.exists(b => book.appliesTo(subject))

case class LazyStudent(field: FieldOfStudy,
						    excuses: List[String]) extends Student:

def knowsAbout(subject: Subject): Boolean = false
						```

---

```scala [1|2|3-4|6-7|9-11|13]
						def oralExam(student: Student): Grade =
						  student match
						    case DiligentStudent(ComputerScience, _) =>
						      blackboardCoding(student)

case DiligentStudent(Linguistics(English), Nil) =>
						      Grade.Fail

case DiligentStudent(Linguistics(Polish), knowledge)
						      if knowledge.contains(Books.Mickewicz) =>
						      askAboutGreatImprovisation(student)

case LazyStudent(_, _) => Grade.Fail
						```

```console
						warning: match may not be exhaustive.
						It would fail on the following input: DiligentStudent(_, _)
						```

---

## State & behavior?

* we can do both: combine, or separate
						* no universal answers!
						* but: often starting with the functional approach works well

---

## Functions as values

```scala
						def examSession(s: Student,
						    exam: Subject => Grade): List[Grade] =
						  ...
						```

```scala
						def oralExam(subject: Subject): Grade = ..

examSession(me, oralExam)
						```

```scala
						trait Student:
						  def takeExam(s: Subject): Grade

examSession(me, me.takeExam)
						```

---

## Immutability

Scala is the only widely adopted immutable-first language.
						What does it mean?

---

```scala [1-2|4-8]
						case class Student(name: String, yearOfStudy: Int,
						  grades: Map[Subject, Grade])

def finishYear(s: Student): Student =
						  if grades.values.forall(_ != Grade.Fail) then
						    s.copy(yearOfStudy = s.yearOfStudy + 1)
						  else
						    s
						```

---

## Collections

```scala [5-6|7|8|9|10|11|1-3]
						case class Result(s: Student, sub: Subject, grade: Grade):
						  def addToStudent: Student =
						    student.copy(grades = student.grades + (sub -> grade))

def exam(sl: List[Student], subs: List[Subject]):
						    List[Student] =
						  sl.flatMap(s => subs.map(sub => (s, sub)))
							.filter((s, sub) => s.attends(sub))
							.map((s, sub) => s.takeExam(sub))
							.filter(result => result.grade != Grade.Fail)
							.map(result => result.addToStudent)
						```

---

## Collections

`Map`s, `Set`s, `List`s, `Vector`s, `Iterator`s, lazy/eager ...

---

## Optionality

* many languages use `null`
						* almost absent in Scala
						* instead, use `Option`

```scala
						trait Student:
						  def thesisTitle: Option[Title]

me.thesisTitle match
						  case Some(title) => println(title)
						  case None 		   => println("Will be ready next week!")
						```

---

## Optionality as a collection

```scala
						val mightUnderstand = me.thesisTitle
						  .map(_.language)
						  .filter(_.isLatin)
						  .isDefined
						```

---

## Optionality as an error

```scala [2|3|4|1,5]
						val defended: Option[Grade] = for {
						  thesis <- me.thesis
						  when <- supervisor.availableTimeSlots.headOption
						  where <- roomsWithProjector.find(_.hasFreeSlot(when))
						} yield defend(thesis, when, where)
						```

---

## Why immutability?

1. Local reasoning

```scala
						val sl: List[Student] = ...
						val grades: Map[Student, Grade] = simulateExam(sl)

// are the original students modified?
						```

Anti-fragility

---

## Why immutability?

2. Concurrency

```scala
						val sl: List[Student] = ...
						fork {
						  calculateUniversityRanking(sl)
						}
						fork {
						  val results = runExam(sl)
						  updateStudentsWithResults(sl, results)
						}
						```

Data safety

---

## Why type safety?

* compile-time verification
						* less tests
						* documentation
						* eliminate bugs
						* IDE completion
						* refactor with confidence
						* generate code

29cd042c638d

---

## How is Scala type-safe?

Generics, but done properly:

```scala
						class Room[T](inhabitants: Set[T]):
						  def moveIn(t: T): Room[T] = ...
						  def count: Int = ...
						```

---

## What is `List`?

```scala
						val l1: List[String] = List("a", "b", "c")
						val l2: List[Student] = ...
						val l3: List[Int] = List(1, 2, 3)
						```

`List` is a <span class="fragment highlight-red">type constructor</span>

---

## Using a type constructor

```scala [1-2|4-5|7-9]
						trait Mappable[F[_]]:
						  def map[A, B](fa: F[A])(f: A => B): F[B]

object ListIsMappable extends Mappable[List]:
						  def map[A, B](fa: List[A])(f: A => B): List[B] = ...

object FutureIsMappable(using ExecutionContext)
						    extends Mappable[Future]:
						  def map[A, B](fa: Future[A])(f: A => B): Future[B] = ...
						```

---

## Using a mappable

```scala [4-6|10-13]
						trait Mappable[F[_]]:
						  def map[A, B](fa: F[A])(f: A => B): F[B]

def gradeStudent[F[_]](s: F[Student],
						    f: Student => Grade)(m: Mappable[F]): F[Grade] =
						  m.map(s)(f)

gradeStudent(List(student1, student2), oralExam)(
						  ListIsMappable)
						gradeStudent(database.find(studentId), oralExam)(
						  FutureIsMappable(...))
						```

---

## From types, to code

```scala [4-8]
						trait Mappable[F[_]]:
						  def map[A, B](fa: F[A])(f: A => B): F[B]

given Mappable[List]:
						  def map[A, B](fa: List[A])(f: A => B): List[B] = ...

given Mappable[Future](using ExecutionContext):
						  def map[A, B](fa: Future[A])(f: A => B): Future[B] = ...
						```

---

## Using a mappable, but shorter

```scala [4-6|10-11]
						trait Mappable[F[_]]:
						  def map[A, B](fa: F[A])(f: A => B): F[B]

def gradeStudent[F[_]](s: F[Student],
						    f: Student => Grade)(using Mappable[F]): F[Grade] =
						  summon[Mappable[F]].map(s)(f)

gradeStudent(List(student1, student2), oralExam)
						gradeStudent(database.find(studentId), oralExam)
						```

---

## Type classes

How to capture common properties of types, we can't/ don't want to modify?

`Mappable` is a type class

---

## Another type class example

```scala
						trait Scientist[T]:
						  def canResearch(who: T, sub: Subject): Boolean

given Scientist[Student]:
						  def canResearch(who: Student, sub: Subject): Boolean = true

given Scientist[Professor]:
						  def canResearch(who: Professor, sub: Subject): Boolean =
							who.knowsAbout(sub)
						```

`Scientist` is a type class

---

## Another example of using a type class

```scala [1-5|7-8]
						def solve[T](by: T, what: Subject)(using Scientist[T]) =
						  if summon[Scientist[T]].canResearch(who, sub)
						    println("Problem solved!")
						  else
						    println("No idea!")

val me: Student = ...
						solve(me, subject)
						```

---

## Yet another example of a type class

```scala [1-3|5-12]
						trait JsonCodec[T]:
						  def encode(t: T): String
						  def decode(s: String): Either[Error, T]

given JsonCodec[Student]:
						  def encode(s: Student): String = s"""
						    {
						      "name": "${s.name}",
						      ...
						    }
						    """
						  def decode(s: String): Either[Error, Student] = ...
						```

---

## Automatic derivation

```scala
						inline given JsonCodec[T] = ${ deriveJsonCodec[T] }

def deriveJsonCodec[T: Type](using Quotes): Expr[String] =
						  val objType = TypeRepr.of[T]
						  objType.typeSymbol.caseFields match { case fields =>
						    fields.map { field =>
						      val fieldName = Expr(field.name)
						      val fieldValue = Select(objExpr.asTerm, field).asExpr
						      field.tree match {
						        case vd: ValDef =>
						          vd.tpt.tpe.asType match {
						            case '[String] =>
						              '{ $fieldName + ": \"" + $fieldValue + "\"" }
						            case '[Int]    =>
						              '{ $fieldName + ": " + $fieldValue.toString }
						        case _ =>
						          report.error("Unsupported field type")
						  (...)
						  }
						```

---

## More inlines

```scala
						inline def repeatWhile(inline f: Boolean): Unit =
						  var loop = true
						  while loop do loop = f
						```

Usage:

```scala
						repeatWhile {
						  receive() match
						    case Done     => false
						    case Value(t) => println(t); true
						}
						```

---

## Case study: http endpoints with tapir

Describe an HTTP endpoint as a data structure, then:

* no behavior, just meta-data
						* generate documentation
						* expose as a server

```scala
						val submitExam: PublicEndpoint[Unit, Unit] =
						  endpoint
						    .post
						    .in("exam" / "submit")
						```

---

```scala
						val submitExam: PublicEndpoint[Solution, Unit] =
						  endpoint
						    .post
						    .in("exam" / "submit")
						    .in(jsonBody[Solution])
						```

---

```scala
						val submitExam: PublicEndpoint[(Solution, Token), Unit] =
						  endpoint
						    .post
						    .in("exam" / "submit")
						    .in(jsonBody[Solution])
						    .in(query[Token]("token"))
						```

---

```scala
						val submitExam: PublicEndpoint[(Solution, Token), Unit] =
						  endpoint
						    .post
						    .in("exam" / "submit")
						    .in(jsonBody[Solution])
						    .in(query[Token]("token")
						      .description("Issued by the dean's office"))
						```

---

```scala
						val submitExam: PublicEndpoint[(Solution, Token), Unit] =
						  endpoint
						    .post
						    .in("exam" / "submit")
						    .in(jsonBody[Solution].example(Solution(42))
						    .in(query[Token]("token")
						      .description("Issued by the dean's office"))
						```

---

```scala
						val submitExam: PublicEndpoint[(Solution, Token), Result] =
						  endpoint
						    .post
						    .in("exam" / "submit")
						    .in(jsonBody[Solution].example(Solution(42))
						    .in(query[Token]("token")
						      .description("Issued by the dean's office"))
						    .out(jsonBody[Result])
						```

## Interpreting the endpoint

```scala [1-2|4-7]
						def createSchema:
						  List[PublicEndpoint[...]] => OpenAPISchema = ...

def exposeEndpoint:
						  PublicEndpoint[INPUT, OUTPUT, ...] =>
							(INPUT => OUTPUT) =>
							HttpRoute = ...
						```

---

---

## Exposing the endpoint

We need to couple the description with matching server-side logic.

How to implement and organize the code?

* often complex
						* needs to be properly modularized

---

```scala
						class Database(cf: ConnectionFactory)

class StudentRepository(db: Database):
						  def find(id: StudentId): Option[Student] = ...
						  def save(s: Student): Unit = ...

trait ExamVerification:
						  def verify(s: Student, e: Exam): Result = ...
						class ManualVerification extends ExamVerification
						class AutomaticVerification extends ExamVerification

class ExamService(repo: StudentRepository,
						    verify: ExamVerification):
						  def submitExam(s: Student, e: Exam): Result = ...
						```

---

## FP in the small, OO in the large

---

## Scala use-cases

* server-side programming
						* concurrent / parallel programming
						* data processing
						* command-line tools (scala-cli)
						* data science (Spark)
						* frontend (Scala.js)
						* chess (lichess)

---

## How to start with Scala?

* [scala-lang.org](https://www.scala-lang.org)
						* [scastie](https://scastie.scala-lang.org)
						* [adopt tapir](https://adopt-tapir.softwaremill.com)
						* [FP in Scala (video)](https://www.coursera.org/specializations/scala)
						* [Rock the JVM](https://rockthejvm.com)
						* [Programming in Scala](https://www.amazon.pl/Programming-Scala-Fifth-Martin-Odersky/dp/0997148004)
						* [FP in Scala (book)](https://www.amazon.pl/Functional-Programming-Scala-Michael-Pilquist/dp/1617299588/ref=asc_df_1617299588/)

---

---

```scala
						println("Thank you!")
						```

<a href="https://twitter.com/adamwarski">@adamwarski</a> /
						<a href="https://softwaremill.social/@adamwarski">@softwaremill.social</a>