type MyF64 = f64

struct SelectorCastHolder {
	x  ?f64
	ax ?MyF64
}

struct GenericSelectorCastHolder[T] {
	x ?T
}

fn result_f64() !f64 {
	return error('no f64')
}

fn result_f32() !f32 {
	return error('no f32')
}

fn option_f64() ?f64 {
	return none
}

fn result_my_f64() !MyF64 {
	return error('no MyF64')
}

fn option_my_f64() ?MyF64 {
	return none
}

fn result_generic[T]() !T {
	return error('no generic')
}

fn cast_or_block_return() int {
	return int(result_f64() or { return 7 })
}

fn keep_none() ?f64 {
	return option_f64() or { none }
}

fn keep_error() !f64 {
	return result_f64() or { error('fallback') }
}

fn selector_cast_return(h SelectorCastHolder) int {
	return int(h.x or { return 7 })
}

fn selector_keep_none(h SelectorCastHolder) ?f64 {
	return h.x or { none }
}

fn selector_keep_error(h SelectorCastHolder) !f64 {
	return h.x or { error('fallback') }
}

fn test_or_block_result_cast() {
	a := int(result_f64() or { 256.0 })
	b := int(result_f64() or { f64(256.0) })
	c := int(result_f32() or { f32(42.0) })
	d := int(option_f64() or { 128.0 })
	e := int(option_f64() or { f64(128.0) })

	assert a == 256
	assert b == 256
	assert c == 42
	assert d == 128
	assert e == 128
}

fn test_or_block_result_cast_alias_payload() {
	a := int(result_my_f64() or { MyF64(64.0) })
	b := int(option_my_f64() or { MyF64(32.0) })

	assert a == 64
	assert b == 32
}

fn test_or_block_result_cast_generic_call() {
	a := int(result_generic[f64]() or { f64(16.0) })

	assert a == 16
}

fn test_or_block_cast_preserves_parent_exits() {
	assert cast_or_block_return() == 7
	assert keep_none() == none

	if _ := keep_error() {
		assert false
	} else {
		assert err.msg() == 'fallback'
	}
}

fn test_or_block_selector_cast() {
	h := SelectorCastHolder{}
	gh := GenericSelectorCastHolder[f64]{}

	a := int(h.x or { 3.0 })
	b := int(h.x or { f64(4.0) })
	c := int(h.ax or { MyF64(5.0) })
	d := int(gh.x or { f64(6.0) })

	assert a == 3
	assert b == 4
	assert c == 5
	assert d == 6
}

fn test_or_block_selector_cast_preserves_parent_exits() {
	h := SelectorCastHolder{}
	assert selector_cast_return(h) == 7
	assert selector_keep_none(h) == none

	if _ := selector_keep_error(h) {
		assert false
	} else {
		assert err.msg() == 'fallback'
	}
}

fn test_or_block_result_void_context() {
	mut seen := false
	result_f64() or { seen = true }
	assert seen

	result_f64() or {}
}