Generics implementing interface

[sudokit]

Is it possible to constrain a generic to implement a interface?
something like this:

pub interface Boo {
	// `x` and `y`
	pos() (f32, f32)
}

pub struct Foo[T implements Boo] {
}

[jorgeluismireles]

You could check if T is Boo inside a new_foo method which returns a result !Foo[T]:

pub interface Boo {
	pos() (f32, f32)
}

struct Foo[T]{ x f32 y f32 }

struct Origin { }
fn (o Origin) pos() (f32, f32) { return 0, 0 }

struct Int { x int y int }
fn (i Int) pos() (f32, f32) { return f32(i.x), f32(i.y) }

fn new_foo[T](t T) !Foo[T] {
	$if t is Boo {
		x, y := t.pos()
		return Foo[T]{ x:x, y:y }
	}
	return error('${t} is not Boo')
}

fn main() {
	s := new_foo(Origin{})!
	println('${s}')
	i := new_foo(Int{1,2})!
	println('${i}')
	x := new_foo('string') or { println('${err}'); exit(1) }
	println('${x}')
}

Result:

Foo[Origin]{
    x: 0.0
    y: 0.0
}
Foo[Int]{
    x: 1.0
    y: 2.0
}
string is not Boo
Exited with error status 1

Both Origin and Int are valid "positions". string is invalid and you should reject it.

[jorgeluismireles]

Another approach with options and saving boo in foo to call pos() later:

pub interface Boo {
	pos() (f32, f32)
}

struct Foo[T]{ boo Boo }

struct Origin { }
fn (o Origin) pos() (f32, f32) { return 0, 0 }

struct Int { x int y int }
fn (i Int) pos() (f32, f32) { return f32(i.x), f32(i.y) }

fn new_foo[T](t T) ?Foo[T] {
	$if t is Boo {
		return Foo[T]{ boo: t }
	}
	return none
}

fn main() {
	if o := new_foo(Origin{}) { println(o.boo.pos()) } // (0.0, 0.0)
	if i := new_foo(Int{1,2}) { println(i.boo.pos()) } // (1.0, 2.0)
	if s := new_foo('string') { println(s.boo.pos()) } // empty
}