aNat : Nat
aNat = 123

anInt : Int
anInt = +789

aText : Text
aText = "A Text value"

aChar : Char
aChar = ?a

val anInt : Int = 123

val aString : String = "A String value"

val aChar : Char = 'a'

In Scala, positive integers are created without the +. In Unison, Nat is the type for positive integers, all Int literals in Unison must include + or -.

aList : [Int]
aList = [+1, +2, -3, -4, +0]

aMap : Map Text Nat
aMap = Map.fromList [("a", 1), ("b", 2), ("c", 3)]

someVal : Optional Boolean
someVal = Some true
noneVal = None

eitherVal : Either Text Nat
eitherVal = Right 2468 |> Either.mapRight (n -> n + 1)

theUnitVal : ()
theUnitVal = ()

notImplemented : [Boolean]
notImplemented = todo "a placeholder"

Type arguments in signatures are delimited by spaces, not square brackets.

val aList : List[Int] = List(1, 2, -3, -4, 0)

val aMap : Map[String, Int] = Map(("a", 1), ("b", 2), ("c", 3))

val someVal : Option[Boolean] = Some(true)
val noneVal = None

val eitherVal : Either[String, Int] = Right(2468).map(_ + 1)

val theUnitVal : Unit = ()

val notImplemented : List[Boolean] = ???

var aVariable = 0
aVariable + 3

Unison does not have an analog to the var keyword in Scala.

splitDigitsOn : Char -> Text -> [Text]
splitDigitsOn delim text =
  Text.split delim text
    |> List.map (cell -> Text.filter isDigit cell)

Unison is a whitespace-significant language, so the function body is scoped by newlines and indentation.

Lambdas are introduced with parens: (arg1 arg2 -> impl). The arrow -> separates the arguments of the lambda from its body.

The |> operator emulates the chaining of .split and .map in Scala.

def splitDigitsOn(delim : Char, text : String) : List[String] = {
  text.split(delim)
    .map(cell => cell.filter(_.isDigit))
    .toList
}

Scala uses dot notation syntax, as in text.split, to call split on the text argument. Unison takes the text value as an argument to another function, Text.split.

It's a common mistake to forget to supply the last argument to Unison functions like List.map because of this convention.

During function application, arguments are separated by spaces:

digits = splitDigitsOn ?| "abc12|def34|56|78"

Since commas are not used to explicitly separate arguments, parenthesis disambiguate the order in which functions should be applied.

Arguments are provided in parentheses, separated by commas:

val digits = splitDigitsOn('|', "abc12|def34|56|78")

digits = splitDigitsOn ?| ("abc12|" ++ "def34|56|78")

val digits = splitDigitsOn('|', "abc12|" ++ "def34|56|78")

identity : a -> a
identity a = a

def identity[A](a: A): A = a

Unison delayed computations are functions with no arguments (thunks.)

In type signatures, they’re indicated with the single quote syntax sugar 'a, short for () -> a. In the body of a function, they are introduced with the ' or do keyword.

computeTwice : '{IO, Exception} Nat -> Nat
computeTwice x =
  x() + x()

expensiveComputation : '{IO, Exception} Nat
expensiveComputation = do
  printLine("Running...")
  42

computeTwice(expensiveComputation())

-- Prints the message twice

The syntax for forcing a thunk in Unison is x() or !x.

Scala has non-forced function arguments using call-by-name parameters (=> T). Scala defers the value every time the parameter is used inside the function.

def computeTwice(x: => Int): Int = x + x

def expensiveComputation(): Int = {
  println("Running...")
  42
}

computeTwice(expensiveComputation())

// Prints the message twice

Scala’s lazy values are different from delayed computations because they memoize the value once evaluated.

lazy val expensiveComputation: Int = {
  println("Computing...")
  42
}

println(expensiveComputation)
println(expensiveComputation)

// Prints the message only once

namespace models

type User = User Text Nat

User.toJson : User -> Json
User.toJson user = todo "unimplemented"

type UserPreferences = UserPreferences [Text]

It's more common to see namespaces fully prefixed by their dot-separated name segments in a scratch.u file:

type models.User = User Text Nat

models.User.toJson : User -> Json
models.User.toJson user = todo "unimplemented"

type models.UserPreferences = UserPreferences [Text]

package models

case class User(name: String, age: Int)

object User {
  def toJson(user: User): String = ???
}

case class UserPreferences (preferences: List[String])

-- imports everything in the `models.User` namespace
use models.User
-- imports the `User` and `UserPreferences` namespaces
use models User UserPreferences
-- imports specific terms from the `models.User` namespace
use models.User toJson fromJson

sqrtplus1 : Float -> Float
sqrtplus1 x =
  use Float sqrt
  sqrt x + 1.0

// imports everything in the `models` package.
import models.*
// imports specific members from the `models` package
import models.{User, UserPreferences}
// Scala supports renaming imports, Unison does not.
import models.UserPreferences as UPrefs

def sqrtplus1(x: Int) =
  import scala.math.sqrt
  sqrt(x) + 1.0

-- A singe line comment.

{-
  A multi-line comment.

  Comments are not saved in the codebase!
-}

myTerm =
  _ = "This text literal will
  be saved to the codebase"
  123 + 456

// A single line comment.

/*
  A multi-line comment.
*/

{{
  This Unison {type Doc} describes something called {myTerm}.

  @signature{myTerm, Map.fromList}

  It can evaluate pure code for dynamic examples:

  ```
  myTerm
  ```

  ```
  Map.fromList [(1, "a"), (2, "b"), (3, myTerm)]
    |> Map.get 3
  ```

  If you change the implementation of `myTerm`,
  this document will change automatically.
}}
myTerm =
  _ = "This text literal will
  be saved to the codebase"
  123 + 456

If a Doc element is created above a term or type, it will automatically share the name of the term or type suffixed with .doc .

/** A Scala Doc for the term below.

With annotations it can automatically update some
information about its inputs and outputs.

It cannot run live snippets of the code it describes.
*/
val myTerm = 123 + 456

type Floor = Floor Nat Boolean

type Direction = Up | Down

floor2: Floor
floor2 = Floor 2 false
up : Direction
up = Direction.Up

The type keyword introduces a new type. Its data constructors are separated by | on the right of the equals sign.

Think of data constructors as functions which produce values of the given type.

-- the Floor type has one data constructor,
-- a function that looks like this
Floor.Floor : Nat -> Boolean -> Floor

case class Floor(number: Int, isPrivate : Boolean)

sealed trait Direction
case object Up extends Direction
case object Down extends Direction

val floor2 : Floor = Floor(2, false)
val up : Direction = Up

Scala’s type system includes more complex ways of expressing type hierarchies through traits, objects, and classes.

type Elevator = {
  currentFloor : Floor,
  direction: Direction,
  requests : [Foor]
}

elevator = Elevator (Floor 3 false) Down [(Floor 2 false)]

Elevator.currentFloor elevator

Elevator.direction.set Up elevator
Elevator.currentFloor.modify(cases (Floor n p) -> Floor (n + 1) p) elevator

case class Elevator(
  currentFloor: Floor,
  direction: Direction,
  requests: List[Floor]
)

val elevator = Elevator(Floor(3, false), Down, List(Floor(2, false)))

elevator.currentFloor

elevator.copy(direction = Up)

Case classes don’t have a modify function for their fields

type Floor = Floor Nat Boolean

type PanelButton = FloorB Floor | DoorOpen | DoorClose | Emergency

In Unison, if we wanted to keep our Floor type separate from the new PanelButton type (since some business logic may only deal with the Floor and not the panel), we would introduce a wrapper data constructor in our PanelButton type.

sealed trait PanelButton
case object DoorOpen extends PanelButton
case object DoorClose extends PanelButton
case object Emergency extends PanelButton
case class Floor(number: Int, isPrivate : Boolean) extends PanelButton

In Scala, you can add a trait and say that the existing Floor case class is a variant of the PanelButton type. This is a “tagged union,” because each case in the PanelButton trait is tagged with its own type.

type Person = Person Text Nat

toText : Person -> Text
toText person = match person with
  Person n a -> "Name: " ++ n ++ (", Age: " ++ (toText a))

In Unison, the match ... with syntax can be replaced with cases:

toText : Person -> Text
toText = cases
  Person n a -> "Name: " ++ n ++ (", Age: " ++ (toText a))

case class Person(name: String, age: Int)

def toString(person: Person): String = person match {
  case Person(n, a) => s"Name: $n, Age: $a"
}

categorizeNumber : Int -> Text
categorizeNumber n = match n with
  n | n > +0 -> "Positive number"
  0 -> "Zero"
  n | n < +0 "Negative number"

def categorizeNumber(num: Int): String = num match {
  case n if n > 0  => "Positive number"
  case 0           => "Zero"
  case n if n < 0  => "Negative number"
}

type User Text Nat

userTuple : User -> (User, Text)
userTuple user = match user with
  u @ User n a ->  (u, n)

case class User(name: String, age: Int)

def userTuple(user : User): (User, String) = user match {
  case u @ User(n, a) => (u, n)
}

type Box t = Box t

describeBox : Box t -> Text
describeBox b = match b with
  Box _ -> "Cannot get type information from generic type t"

Instead, Unison pattern matches on the data constructors of the type:

type Box t = BoxNat Nat | BoxText Text | BoxOther t

describeBox : Box t -> Text
describeBox b = match b with
  (BoxNat _) -> "Box of a Nat"
  (BoxText _) -> "Box of a Text"
  (BoxOther _) -> "Box of something else"

case class Box[T](value: T)

def describeBox[T](box: Box[T]): String = box match {
  case Box(_: Int)    => "Box of an integer"
  case Box(_: String) => "Box of a string"
  case _              => "Box of something else"
}

List.uncons : [a] -> Optional (a, [a])
List.uncons list = match list with
    x +: xs -> Some (x, xs)
    []      -> None

List.slidingPairs : [a] -> [(a,a)]
List.slidingPairs list =
  loop acc = cases
    [fst, sec] ++ tail ->
      loop (acc :+ (fst, sec)) (sec +: tail)
    _ -> acc
  loop [] list

Pattern match on a list of n elements with the regular list constructor [fst, second]

def uncons[A](list: List[A]): Option[(A, List[A])] = list match {
  case x :: xs => Some((x, xs))
  case Nil     => None
}

def slidingPairs[A](list: List[A]): List[(A, A)] = {
  def loop(remaining: List[A], acc: List[(A, A)]): List[(A, A)] = remaining match {
    case fst :: sec :: tail => loop(sec :: tail, (fst, sec) :: acc)
    case _ => acc.reverse
  }
  loop(list, Nil)
}

main : '{IO, Exception} ()
main = do
  printLine "Hello world!"

mainWithArgs : '{IO, Exception} ()
mainWithArgs = do
  args : [Text]
  args = IO.getArgs()
  printLine ("program args: " ++ (Text.join ", " args))

pureMain : '{} Nat
pureMain = do
  42

object Main extends App {
    println("Hello world!")
}

object Main {
  def main(args : Array[String]) Unit = {
    println("Hello world!")
  }
}

factorial n = product (range 1 (n + 1))

> factorial 3

UCM will print out:

> factorial 3
  ⧨
  6

scala> val x = 42
x: Int = 42

scala> x + 10
res0: Int = 52