Hylo (original) (raw)

MVS & Theory

• Extending Swift’s subscripts with inout projections
• Method bundles
• Structured concurrency made easy: thread hopping, no function coloring
• Expressing double linked lists with value semantics is safe and faster than doing it with reference semantics.

Compiler

• Compilation using LLVM
• Novel techniques for compiling generics with coherence
• Caching and serialization of the compiler’s program state
• C interop research

Standard Library

• See the documentation of the current implementation with some fundamental traits and data structures.
• Positionless Collection Algorithms
• rs-stl: A Rust port of the C++ STL algorithms for improved generic programming

Developer Experience

• VSCode extension with syntax highlighting and code execution
• Documentation compiler
• Language Server prototype

Compiler DevOps

• Development Containers support - easy to get started
• Support SPM/CMake, Ninja/Xcode, Windows/Linux/macOS
• Test generation compiler plugin
• Pre-built Hylo development toolchain Docker images
• Compiler written in Swift 6.2

Research Around Hylo

Section titled “Research Around Hylo”

Even though the compiler and standard library are still in their early stages, we can already show some advanced examples of Hylo code that you can try out on Compiler Explorer.

Subscripts - A Safe Projection Mechanism

Section titled “Subscripts - A Safe Projection Mechanism”

https://godbolt.org/z/Mzz17c5z1

/// The orientation of a 2D vector.

public type Angle: Deinitializable {

  /// The value of `self` in radians.

  public var radians: Float64

  /// Creates an instance with its value in radians.

  public memberwise init

  /// Creates an instance with its value in degrees.

  public init(degrees: Float64) {

    &self.radians = degrees * Float64.pi() / 180.0

  }

  /// The value of `self` in degrees.

  public property degrees: Float64 {

    let { radians * 180.0 / Float64.pi() }

    inout {

      var d = radians * 180.0 / Float64.pi()

      yield &d

      &self.radians = d * Float64.pi() / 180.0

    }

  }

}

public fun main() {

  var a = Angle(radians: .pi())

  inout d = &a.degrees

  precondition(d == 180.0)

  &d = 0.0

  precondition(a.radians == 0.0)

}

Sink Methods - Capability for Deinitializing

Section titled “Sink Methods - Capability for Deinitializing”

https://godbolt.org/z/cY7T5jPEc

/// A computer that must be explicitly shut down using a sink method.

type Computer {

  public var ram: String

  public memberwise init

  public fun shutdown() sink -> Void {

    print("Key received, shutting down... Memory contents was: ")

    print(self.ram)

    /// Sinking all parts

    _ = self.ram

  }

}

fun test1() {

  var computer = Computer(ram: "Important data")

} Cannot deinit `computer`

fun test2() {

  var computer = Computer(ram: "Important data")

  if random_bool() {

    computer.shutdown()

  }

} Cannot deinit `computer` [when `if` not entered]

fun test3() {

  var computer = Computer(ram: "Important data")

  while random_bool() {

    computer.shutdown() Use of consumed object [after first iteration]

  }

} Cannot deinit `computer` [when `while` not entered]

fun random_bool() -> Bool {

  return false // Generated using a fair dice roll % 2.

}

type A: Deinitializable {

  public var witness: Int

  public var x: Int

  public init(x: sink Int) {

    &self.x = x

    &self.witness = 0

  }

}

conformance A: Movable {

  public fun take_value(from source: sink Self) {

    set {

      &self.x = source.x

      &self.witness = 0

    }

    inout {

      &self.x = source.x

      &self.witness += 1

    }

  }

}

public fun main() {

  var s = A(x: 1)

  &s = A(x: 2)

  &s = A(x: 2)

  precondition(s.x == 2)

  precondition(s.witness == 2)

}

See more examples in the compiler test suite.