Values, Variables & Literals

//> using scala 3.10.0

@main def trailheadVals(): Unit =
  val trailName = "Cabane Alpine"   // inferred String, cannot be reassigned
  val lengthKm: Double = 12.5       // explicit type annotation
  var restStops = 0                 // inferred Int, can be reassigned
  restStops += 1
  restStops = restStops + 1

  println(s"$trailName: $lengthKm km, $restStops rest stops")
  assert(restStops == 2)

Cabane Alpine: 12.5 km, 2 rest stops

//> using scala 3.10.0

@main def reassign(): Unit =
  val ascentM = 840
  ascentM = 900

-- [E052] Type Error: f02.scala:5:10
5 |  ascentM = 900
  |  ^^^^^^^^^^^^^
  |  Reassignment to val ascentM
  |
  | longer explanation available when compiling with `-explain`
1 error found
Compilation failed

//> using scala 3.10.0

@main def valueTypes(): Unit =
  val b: Byte = 127
  val s: Short = 32767
  val i: Int = 2147483647
  val l: Long = 9223372036854775807L
  val f: Float = 3.4028235f
  val d: Double = 1.7976931348623157e308
  val c: Char = 'A'
  val flag: Boolean = true
  val nothingMuch: Unit = ()

  println(List(b, s, i, l, f, d, c, flag, nothingMuch).mkString(", "))
  println(Int.MaxValue + 1)                 // wraps around silently
  println(Int.MaxValue.toLong + 1)          // widen first to avoid it
  println(10 / 4)                           // integer division
  println(10 / 4.0)
  println(-7 / 2)
  println(-7 % 2)
  println(7.0 / 0)                          // no exception for floating point
  println(Double.NaN == Double.NaN)
  try Math.addExact(Int.MaxValue, 1)
  catch case e: ArithmeticException => println(e.getMessage)

127, 32767, 2147483647, 9223372036854775807, 3.4028234, 1.7976931348623157E308, A, true, ()
-2147483648
2147483648
2
2.5
-3
-1
Infinity
false
integer overflow

//> using scala 3.10.0

@main def bigNumbers(): Unit =
  val big = BigInt("123456789012345678901234567890")
  println(big * 2)
  println(BigInt(2).pow(100))

  println(0.1 + 0.2)                                   // Double
  println(BigDecimal("0.1") + BigDecimal("0.2"))       // exact
  println(BigDecimal(0.1) + BigDecimal(0.2))           // built from a Double: 0.1 is already rounded
  println(BigDecimal("1.10") == BigDecimal("1.1"))
  println(BigDecimal("10.005").setScale(2, BigDecimal.RoundingMode.HALF_UP))

246913578024691357802469135780
1267650600228229401496703205376
0.30000000000000004
0.3
0.3
true
10.01

//> using scala 3.10.0

@main def literals(): Unit =
  val dec = 1_000_000          // underscores are ignored
  val hex = 0xCAFE_BABE        // Int: wraps to a negative number
  val bin = 0b1010_1010        // binary literal
  val mask = 0xFFFFFFFFL       // L makes it a Long
  val lng = 1_000_000_000_000L
  val dbl = 6.02e23
  val flt = 2.5f
  val ch = 'x'
  val uni = '\u0041'
  val tab = "tab\tseparated"
  val tf = true
  val nothing: String | Null = null

  println(List(dec, hex, bin, mask, lng).mkString(" "))
  println(List(dbl, flt).mkString(" "))
  println(s"$ch $uni $tab $tf $nothing")
  println(s"${hex.getClass.getSimpleName} ${mask.getClass.getSimpleName} ${dbl.getClass.getSimpleName} ${flt.getClass.getSimpleName}")
  println(List(.5, 1e-3, 0x1F, 0XFF, 100L, 1.5F, 2D))
  println(0xFFFFFFFF == -1)

1000000 -889275714 170 4294967295 1000000000000
6.02E23 2.5
x A tab	separated true null
int long double float
List(0.5, 0.001, 31, 255, 100, 1.5, 2.0)
true

//> using scala 3.10.0

@main def literalErrors(): Unit =
  val tooBigForInt = 3000000000
  val tooBigForByte: Byte = 200

-- Error: f06.scala:4:21
4 |  val tooBigForInt = 3000000000
  |                     ^^^^^^^^^^
  |                     number too large
-- [E007] Type Mismatch Error: f06.scala:5:28
5 |  val tooBigForByte: Byte = 200
  |                            ^^^
  |                            Found:    (200 : Int)
  |                            Required: Byte
  |
  | longer explanation available when compiling with `-explain`
2 errors found
Compilation failed

//> using scala 3.10.0

@main def leadingZeros(): Unit =
  val a = 010
  val b = 08
  println((a, b))

(10,8)

//> using scala 3.10.0

@main def nulls(): Unit =
  val s: String = null           // allowed: Null is a subtype of every reference type
  println(s)
  println(s == null)

null
true

//> using scala 3.10.0
//> using option -Yexplicit-nulls

@main def explicitNulls(): Unit =
  val s: String = null

-- [E007] Type Mismatch Error: f15.scala:5:18
5 |  val s: String = null
  |                  ^^^^
  |Found:    Null
  |Required: String
  |Note that implicit conversions were not tried because the result of an implicit conversion
  |must be more specific than String
  |
  | longer explanation available when compiling with `-explain`
1 error found
Compilation failed

//> using scala 3.10.0
import scala.compiletime.uninitialized

class Sensor:
  var reading: Double = uninitialized   // the default of the type: 0.0
  var label: String = uninitialized     // null
  var count: Int = uninitialized        // 0
  var active: Boolean = uninitialized   // false

@main def uninit(): Unit =
  val s = Sensor()
  println(s"${s.reading} ${s.label} ${s.count} ${s.active}")
  assert(s.reading == 0.0 && s.label == null && s.count == 0 && !s.active)

0.0 null 0 false

//> using scala 3.10.0

class Sensor:
  var reading: Double = _

@main def oldStyle(): Unit = println(Sensor().reading)

-- Warning: f09.scala:4:24
4 |  var reading: Double = _
  |                        ^
  |`= _` has been deprecated; use `= uninitialized` instead.
  |`uninitialized` can be imported with `scala.compiletime.uninitialized`.
  |This construct can be rewritten automatically under -rewrite -source 3.4-migration.
1 warning found
0.0

//> using scala 3.10.0
//> using option -deprecation

@main def widening(): Unit =
  val i: Int = 123456789
  val l: Long = i                  // Int to Long: exact
  val d: Double = i                // Int to Double: exact
  val c: Int = 'a'                 // Char to Int
  val s: Short = (3: Byte)         // Byte to Short
  println(List(l, d, c, s))

  val f: Float = i                 // Int to Float: loses precision
  println(f)
  val big: Long = 123456789012345678L
  val lossy: Double = big          // Long to Double: loses precision
  println(lossy.toLong)

-- Deprecation Warning: f10.scala:12:17
12 |  val f: Float = i                 // Int to Float: loses precision
   |                 ^
   |method int2float in object Int is deprecated since 2.13.1: Implicit conversion from Int to Float is dangerous because it loses precision. Write `.toFloat` instead.
-- Deprecation Warning: f10.scala:15:22
15 |  val lossy: Double = big          // Long to Double: loses precision
   |                      ^
   |method long2double in object Long is deprecated since 2.13.1: Implicit conversion from Long to Double is dangerous because it loses precision. Write `.toDouble` instead.
2 warnings found
List(123456789, 1.23456789E8, 97, 3)
1.2345679E8
123456789012345680

//> using scala 3.10.0

@main def narrowing(): Unit =
  val d: Double = 3.99
  val i: Int = d

-- [E007] Type Mismatch Error: f12.scala:5:15
5 |  val i: Int = d
  |               ^
  |               Found:    (d : Double)
  |               Required: Int
  |
  | longer explanation available when compiling with `-explain`
1 error found
Compilation failed

//> using scala 3.10.0

@main def conversions(): Unit =
  val d = 3.99
  println(d.toInt)               // truncates toward zero
  println((-3.99).toInt)
  println(d.round)               // nearest Long
  println(300.toByte)            // keeps the low 8 bits
  println(('a' + 1).toChar)      // Char arithmetic gives an Int
  println('a' + 1)
  val code: Char = 97            // an Int literal that fits is accepted as a Char
  println(code)

3
-3
4
44
b
98
a