Here’s a the kind of program we envision writing in Hylo:

subscript longer_of(_ a: inout String, _ b: inout String): String {
  if b.count() > a.count() { yield &b } else { yield &a }
}

fun emphasize(_ z: inout String, strength: Int = 1) {
  z.append(repeat_element("!", count: strength))
}

public fun main() {
  var (x, y) = ("Hi", "World")
  emphasize(&longer_of[&x, &y])
  print("${x} ${y}") // "Hi World!"
}


This program declares two character strings, appends an exclamation mark to the longest, and prints them both after the mutation. No pointers or references are used (& in Hylo does not mean “address of”—it simply marks a mutation), and no unnecessary allocation occurs. The result of longer_of is a projection of the longer argument, so the mutation of z by emphasize occurs directly on the value of y. The value is neither copied, nor moved, and yet it is not being passed by reference to emphasize. The body of emphasize owns z in exactly the same way as it owns strength, which is passed by value: z is an independent value that can only be touched by emphasize.

A Python programmer may think that String has reference semantics and that longer_of is simply returning a reference to y. A C/C++ programmer may think of longer_of as a function that takes and returns pointers or mutable references to values. Neither of these views are quite right. All types in Hylo are value types and their instances behave like ints. As a result, the possible accesses to a function parameter are always visible in the body of that function, and can’t be hidden behind some stored reference.

The language guarantees to emphasize that the value of z will not be accessed via x or y (or any other means) until that function returns.


(extracted from https://www.hylo-lang.org/ )