Language Design: Useful Syntax Sugar

get sugar

Rule

x.get(y) can be written as x(y)

Explanation

Instead of special-purpose syntax that is used for indexing operations (reading) in many languages, like

int firstValue = someArray[0];

one can write

let firstValue = someArray(0)
/* same as */
let firstValue = someArray.get(0)

assuming a definition like

class Array[T]
  fun get(idx: Int64): T = ...

In combination with varargs, it can also replace special-purpose syntax used to construct various data structures.

Instead of e. g.

int[] someArray = int[] { 1, 2, 3 };

one can write

let someArray = Array(1, 2, 3)
/* same as */
let someArray = Array.get(1, 2, 3)

assuming a definition like

module Array
  fun get[T](vals: T*): Array[T] = ...

Of course Array is just one example; this rule applies to other data structures and use-cases equally:

let countriesAndCapitals =
  Map("France" -> "Paris", "Germany" -> "Berlin", ...)
countriesAndCapitals("France") // "Paris"

let baroqueComposers = Set("Bach", "Händel", "Vivaldi", ...)
baroqueComposers("Rammstein")  // false 

set sugar

Rule

x.set(y, z) can be written as x(y) = z

Explanation

Instead of special-purpose syntax that is used for indexing operations (writing) in many languages, like

someArray[0] = 23;

one can write

someArray(0) = 23
/* same as */
someArray.set(0, 23)

assuming a definition like

class Array[T]
  fun set(idx: Int64, val: T): Unit = ...

Of course Array is just one example; this rule applies to other data structures and use-cases equally:

let countriesAndCapitals =
  Map("France" -> "Paris", "Germany" -> "Berlin", ...)
countriesAndCapitals("England") = "London" // new entry added

let baroqueComposers = Set("Bach", "Händel", "Vivaldi", ...)
baroqueComposers("Monteverdi") = true      // new entry added

set... sugar

Rule

x.setY(z) can be written as x.y = z

Explanation

Instead of special-purpose syntax for properties and their setters, like

struct Rating {
  int value {
    get { return value; }
    set {
      if (value < 0 || value > 100)
        throw new ArgumentOutOfRangeException();
      this.value = value;
    }
  }
}

someRating.value = 97;

one can keep writing

someRating.value = 97

assuming a definition like

struct Rating(var value: Int32)
  fun setValue(val: Int32) = ...

but does not have to pay the complexity cost of adding properties to the language.