Overcoming Immutability in Scala

collection_init.java

final List<String> fullNames = new ArrayList<>();
for (Name name : names) {
  fullNames.add(String.format("%s %s", name.getFirst(), name.getLast()));
}

collection_init.scala

val fullNames = names.map { name =>
  s"${name.first} ${name.last}"
}

collection_init_filter.scala

val fullNamesStartingWithM = names
  .filter(_.last.startsWith("M"))
  .map(name => s"${name.first} ${name.last}")

collection_init_streams.java

List<String> fullNamesStartingWithM = 
  names
    .stream()
    .filter(name -> name.getLast().startsWith("M"))
    .map(name -> String.format("%s %s", name.getFirst(), name.getLast()))
    .collect(Collectors.toList());

cond_assignment.java

final Foo foo;
if (someTest()) {
  foo = someFoo;
} else {
  foo = new Foo();
}

cond_assignment.scala

val foo =
  if (someTest()) {
    someFoo
  } else {  
    new Foo
  }

cond_assignment_gotchas.scala

val foo1 =
  if (someTest()) {
    someFoo
  } else {
    new Foo
    println("Using default value for `foo`")
  }

val foo2 =
  if (someTest()) {
    someFoo
  }

val foo3 =
  if (someTest()) {
    someFoo
  } else {
    throw new Exception("No value for `foo` provided!")
  }

cond_assignment_type_annotation.scala

// NOTE: Will not compile, since you explicitly specified your type.
// This is good, since it catches the error below.
val foo: Foo =
  if (someTest()) {
    someFoo
  } else {
    new Foo
    // Developer adds println statement for debugging, but explicit type 
    // on Foo will catch that they changed the type of the expression.
    println("Using default value for `foo`")
  }

defaults.java

final Foo foo;
if (someFoo != null) {
  foo = someFoo;
} else {
  foo = new Foo();
}

defaults.scala

val foo = maybeFoo.getOrElse(new Foo)

defaults_smelly.scala

val foo: Foo =
  if (maybeFoo.isDefined) {
    foo = maybeFoo.get // Option#get is generally a code smell.
  } else {
    foo = new Foo
  }

map_init.java

final Map<Long, User> usersById = new HashMap<>();
for (User user : users) {
  usersById.put(user.getId(), user);
}

map_init.scala

val usersById = {
  val elems = users.map(u => (u.id, u))
  Map(elems: _*) // The _* syntax allows you to pass a sequence as a vararg
}

map_init_apply.scala

def apply[A, B](elems: (A, B)*): Map[A, B]

map_init_toMap.scala

val usersById = users.map(u => (u.id, u)).toMap