hylo

hylo copied to clipboard

camio

Implement synthesization of Copyable conformances

4

``` public type Foo : Regular { var i : Int init(){ &i = 3 } } public conformance Foo: Equatable { public fun infix== (_ other: Self) -> Bool...

camio

It should be possible to synthesize the implementation of all traits inherited by `Regular` for types whose stored properties are known to be `Regular`.

kyouko-taiga

`Deinitializable` conformance not synthesized for lambda type

1

Compile this with 3166db52: ``` fun f() { let x = fun (_ target: set T) -> Void { &target = src.copy() } _ = x } public fun main()...

dabrahams

Implement a type layout algorithm

3

See also: #1065 We should implement a layout algorithm for generation the binary representation of types with a record layout. We should probably use the [same algorithm as Swift](https://github.com/apple/swift/blob/main/docs/ABI/TypeLayout.rst). >...

kyouko-taiga

Implement a way to customize "trap behavior"

5

We need a way to explain how a program can trap without making a system call when it is compiled with `--no-std`. We should probably take inspiration from Rust's [#[panic_handler]](https://doc.rust-lang.org/nomicon/panic-handler.html#panic_handler).

kyouko-taiga

This program should compile: ``` type A: Deinitializable { public memberwise init public fun foo() {} public static fun foo() {} } public fun main() { A().foo() // error: ambiguous...

kyouko-taiga

This type declaration should not compile: ``` type A { fun infix&%!! (_ x: A) -> Void { () } } ``` Commit: 289ed31a49747a3bfbec14547e0ace165d72e3e0

kyouko-taiga

The current implementation doesn't duplicate declarations and simply let overload resolution fail.

kyouko-taiga

We should use `sink` static properties to represent constant properties of types, like the number of bits available in a particular `BinaryInteger`. ``` public extension Int64 { public static property...

kyouko-taiga