proj-plbook-plChFuncLangs

Table of Contents for Programming Languages: a survey

Haskell

Because it is so well-liked, Haskell gets its own chapter.

See chapter on chapter on Haskell

Scala

Scala is a multiparadigm language, both OOP and functional.

Tours and tutorials:

• http://docs.scala-lang.org/tutorials/tour/tour-of-scala.html
• https://twitter.github.io/scala_school/
• https://www.handsonscala.com (free chapters form a tutorial)
• http://lampwww.epfl.ch/teaching/archive/type_systems/2010/docs/week13.pdf
• https://www.scalawithcats.com/dist/scala-with-cats.html
• https://gist.github.com/jdegoes/97459c0045f373f4eaf126998d8f65dc#applied-functional-programming-with-scala---notes

Cons:

• big language
• slow compilation
• culture of punctuation-based DSLs can make readability hard

Best practices:

• http://docs.scala-lang.org/style/
• http://twitter.github.io/effectivescala/

Tutorials and books:

• http://learnxinyminutes.com/docs/scala/
• https://github.com/twitter/scala_school

Comparisons:

• https://agilewombat.com/2016/02/01/scala-vs-kotlin/
• https://leverich.github.io/swiftislikescala/

Features:

• higher-kinded types
• implicits
• " Scala is completely interoperable with Java (and with some qualifications also to C#). A Scala component can: • access all methods and fields of a Java component, • create instances of Java classes, • inherit from Java classes and implement Java interfaces, • be itself instantiated and called from a Java component. " -- [1]
• "Scala’s concepts subsume SML modules. More precisely, (generative) SML modules can be encoded inνObj,but notvice versa." -- [2]
• Abstract Types " Here is a type of “cells” using object-oriented abstraction. trait AbsCell? { type T val init: T private var value: T = init def get: T = value def set(x: T): Unit = { value = x } }

The AbsCell? class has an abstract type member T and an abstract value member init. Instances of that class can be created by implementing these abstract members with concrete definitions.

val cell = new AbsCell? { type T = Int; val init = 1 } cell.set(cell.get * 2)

The type of cell is AbsCell? { type T = Int }.

Path-dependent Types: You can also use AbsCell? without knowing the specific cell type:

def reset(c: AbsCell?): Unit = c.set(c.init);

Why does this work?

• c.init has type c.T
• The method c.set has type c.T => Unit.
• So the formal parameter type and the argument type coincide.
• c.T is an instance of a path-dependent type.

In general, such a type has the form x0...xn.t, where

• x0 is an immutable value
• x1, ..., xn are immutable fields, and
• t is a type member of xn " -- [3]

Some notes on Scala 3 features:

• https://scalacenter.github.io/scala-3-migration-guide/docs/incompatibilities/dropped-features.html
• https://blog.knoldus.com/a-beginner-guide-to-scala-3-0/
• https://dotty.epfl.ch/
• https://dotty.epfl.ch/docs/
• https://dotty.epfl.ch/docs/reference/overview.html
• https://dotty.epfl.ch/docs/reference/features-classification.html
• https://dotty.epfl.ch/docs/reference/contextual/motivation.html (talks about implicits, and what they are being replaced by)
• https://lichess.org/@/thibault/blog/lichess--scala-3/y1sbYzJX

example of scala 3 'givens' which are (part of) the successor to scala implicits:

https://alvinalexander.com/source-code/scala-3-dotty-complete-givens-using-example/

so afaict these are just similar to Haskell typeclass instances. I guess what scala is really contributing is that i think these are lexically scoped, rather than globals like (i think) in Haskell.

Extensions:

• Kepler macro system
• Compiles to Javascript (scala.js) (and this apparently works well [4]