fn ret(s string) string {
	return s
}

fn raise() ?string {
	return none
}

fn xx() {
	s := ret(raise() or { return })
	println(s)
}

fn test_nested_or() {
	xx()
}

fn xx_prop() ?string {
	s := ret(raise()?)
	return s
}

fn test_nested_propagation() {
	a := xx_prop() or { 'propagated' }
	assert a == 'propagated'
}

struct St {
mut:
	z f64
}

fn (mut s St) raise() ?f64 {
	return none
}

fn retf(f f64) f64 {
	return f
}

fn (mut s St) aa() {
	f := retf(s.raise() or { return })
	s.z = 7.5
	println(f)
}

fn test_nested_or_method_call() {
	mut x := St{
		z: 2.25
	}
	x.aa()
	assert x.z == 2.25
}

fn (mut s St) aa_propagate() ? {
	f := retf(s.raise()?)
	s.z = 7.5
	println(f)
}

fn test_nested_propagation_method() {
	mut x := St{
		z: 2.25
	}
	x.aa_propagate() or { x.z = 13.0625 }
	assert x.z == 13.0625
}