struct ReceiverPatternExpect[T] {
    value T
}

struct MixedReceiverPatternBox[T, U] {
    direct T
    items  U
}

type IntListExpect = ReceiverPatternExpect[[]int]
type StringIntMapExpect = ReceiverPatternExpect[map[string]int]
type MixedIntStringListBox = MixedReceiverPatternBox[int, []string]

fn (e ReceiverPatternExpect[T]) broad_receiver_returns_value() T {
    return e.value
}

fn (e ReceiverPatternExpect[[]int]) concrete_array_receiver_returns_len() int {
    return e.value.len
}

fn (e ReceiverPatternExpect[[]int]) same_name_prefers_concrete_receiver() string {
    return 'concrete'
}

fn (e ReceiverPatternExpect[[]int]) same_name_with_method_generic_prefers_concrete_receiver[U](extra U) string {
    return 'concrete'
}

fn (e ReceiverPatternExpect[[]T]) dynamic_array_receiver_pattern_returns_first_or_value(value T) T {
    if e.value.len == 0 {
        return value
    }
    return e.value[0]
}

fn (e ReceiverPatternExpect[[]T]) same_name_prefers_concrete_receiver() string {
    return 'pattern'
}

fn (e ReceiverPatternExpect[[]T]) same_name_with_method_generic_prefers_concrete_receiver[U](extra U) string {
    return 'pattern'
}

fn (e ReceiverPatternExpect[[]T]) dynamic_array_receiver_pattern_pairs_with_method_generic[U](value T,
    extra U) (T, U) {
    if e.value.len == 0 {
        return value, extra
    }
    return e.value[0], extra
}

fn (e ReceiverPatternExpect[map[K]V]) map_receiver_pattern_returns_existing_or_default(key K,
    value V) V {
    if key in e.value {
        return e.value[key]
    }
    return value
}

fn (e ReceiverPatternExpect[map[K]V]) map_receiver_pattern_pairs_with_method_generic[U](key K,
    value V, extra U) (V, U) {
    if key in e.value {
        return e.value[key], extra
    }
    return value, extra
}

fn (e ReceiverPatternExpect[map[K]V]) same_name_map_exact_prefers_concrete[U](extra U) string {
    _ = extra
    return 'pattern'
}

fn (e ReceiverPatternExpect[map[string]int]) same_name_map_exact_prefers_concrete[U](extra U) string {
    _ = extra
    return 'concrete'
}

fn (e ReceiverPatternExpect[map[K]V]) same_name_map_method() string {
    return 'pattern'
}

fn (e ReceiverPatternExpect[map[string]int]) same_name_map_method() string {
    return 'concrete'
}

fn (b MixedReceiverPatternBox[T, []U]) mixed_receiver_pattern_values_with_method_generic[V](fallback U,
    marker V) (T, U, V) {
    if b.items.len == 0 {
        return b.direct, fallback, marker
    }
    return b.direct, b.items[0], marker
}

fn (b MixedReceiverPatternBox[int, []string]) same_name_with_method_generic_prefers_concrete_mixed_receiver[V](marker V) string {
    return 'concrete'
}

fn (b MixedReceiverPatternBox[T, []U]) same_name_with_method_generic_prefers_concrete_mixed_receiver[V](marker V) string {
    return 'pattern'
}

fn test_existing_generic_receiver_declarations_still_work() {
    assert ReceiverPatternExpect[int]{
        value: 7
    }.broad_receiver_returns_value() == 7
    assert ReceiverPatternExpect[[]int]{
        value: [1, 2, 3]
    }.concrete_array_receiver_returns_len() == 3
}

fn test_concrete_receiver_method_takes_precedence_over_structured_pattern() {
    assert ReceiverPatternExpect[[]int]{
        value: [1, 2, 3]
    }.same_name_prefers_concrete_receiver() == 'concrete'
    assert ReceiverPatternExpect[[]string]{
        value: ['alpha']
    }.same_name_prefers_concrete_receiver() == 'pattern'
}

fn test_concrete_receiver_method_with_method_generic_takes_precedence_over_structured_pattern() {
    assert ReceiverPatternExpect[[]int]{
        value: [1, 2, 3]
    }.same_name_with_method_generic_prefers_concrete_receiver('extra') == 'concrete'
    assert ReceiverPatternExpect[[]int]{
        value: [1]
    }.same_name_with_method_generic_prefers_concrete_receiver[string]('extra') == 'concrete'
    assert ReceiverPatternExpect[[]string]{
        value: ['alpha']
    }.same_name_with_method_generic_prefers_concrete_receiver('extra') == 'pattern'
}

fn test_structured_generic_receiver_patterns_can_be_declared() {
    assert true
}

fn test_dynamic_array_receiver_pattern_binds_element_type() {
    assert ReceiverPatternExpect[[]int]{
        value: [1, 2, 3]
    }.dynamic_array_receiver_pattern_returns_first_or_value(9) == 1
    assert ReceiverPatternExpect[[]string]{
        value: ['alpha', 'beta']
    }.dynamic_array_receiver_pattern_returns_first_or_value('fallback') == 'alpha'
}

fn test_dynamic_array_receiver_pattern_binds_nested_element_type() {
    assert ReceiverPatternExpect[[][]int]{
        value: [[1, 2], [3, 4]]
    }.dynamic_array_receiver_pattern_returns_first_or_value([9, 10]) == [1, 2]
    assert ReceiverPatternExpect[[]map[string]int]{
        value: [
            {
                'one': 1
            },
        ]
    }.dynamic_array_receiver_pattern_returns_first_or_value({
        'zero': 0
    })['one'] == 1
}

fn test_dynamic_array_receiver_pattern_method_generic_is_inferred() {
    value, extra := ReceiverPatternExpect[[]int]{
        value: [1, 2, 3]
    }.dynamic_array_receiver_pattern_pairs_with_method_generic(9, 'extra')
    assert value == 1
    assert extra == 'extra'
    explicit_value, explicit_extra := ReceiverPatternExpect[[]int]{
        value: [1, 2, 3]
    }.dynamic_array_receiver_pattern_pairs_with_method_generic[string](9, 'explicit')
    assert explicit_value == 1
    assert explicit_extra == 'explicit'
}

fn test_map_receiver_pattern_binds_key_and_value_types() {
    assert ReceiverPatternExpect[map[string]int]{
        value: {
            'one': 1
        }
    }.map_receiver_pattern_returns_existing_or_default('one', 0) == 1
    assert ReceiverPatternExpect[map[int]string]{
        value: {
            2: 'two'
        }
    }.map_receiver_pattern_returns_existing_or_default(3, 'fallback') == 'fallback'
}

fn test_map_receiver_pattern_method_generic_can_be_explicit() {
    value, extra := ReceiverPatternExpect[map[string]int]{
        value: {
            'one': 1
        }
    }.map_receiver_pattern_pairs_with_method_generic[string]('missing', 7, 'extra')
    assert value == 7
    assert extra == 'extra'
}

fn test_alias_to_array_receiver_pattern_binds_element_type() {
    assert IntListExpect{
        value: [1, 2, 3]
    }.dynamic_array_receiver_pattern_returns_first_or_value(9) == 1
    value, extra := IntListExpect{
        value: [1, 2, 3]
    }.dynamic_array_receiver_pattern_pairs_with_method_generic[string](9, 'alias')
    assert value == 1
    assert extra == 'alias'
    inferred_value, inferred_extra := IntListExpect{
        value: [1, 2, 3]
    }.dynamic_array_receiver_pattern_pairs_with_method_generic(9, 'inferred')
    assert inferred_value == 1
    assert inferred_extra == 'inferred'
}

fn test_alias_to_map_receiver_pattern_binds_key_and_value_types() {
    assert StringIntMapExpect{
        value: {
            'one': 1
        }
    }.map_receiver_pattern_returns_existing_or_default('one', 0) == 1
    value, extra := StringIntMapExpect{
        value: {
            'one': 1
        }
    }.map_receiver_pattern_pairs_with_method_generic[bool]('missing', 7, true)
    assert value == 7
    assert extra
}

fn test_alias_to_map_exact_generic_method_takes_precedence_over_structured_pattern() {
    assert StringIntMapExpect{
        value: {
            'one': 1
        }
    }.same_name_map_exact_prefers_concrete('alias') == 'concrete'
}

fn test_alias_to_map_exact_method_takes_precedence_over_structured_pattern() {
    assert StringIntMapExpect{
        value: {
            'one': 1
        }
    }.same_name_map_method() == 'concrete'
}

fn test_alias_receiver_exact_method_takes_precedence_over_structured_pattern() {
    assert IntListExpect{
        value: [1, 2, 3]
    }.same_name_prefers_concrete_receiver() == 'concrete'
    assert IntListExpect{
        value: [1]
    }.same_name_with_method_generic_prefers_concrete_receiver[string]('extra') == 'concrete'
}

fn test_mixed_direct_and_structured_receiver_pattern_method_generic() {
    direct, item, marker := MixedReceiverPatternBox[int, []string]{
        direct: 7
        items:  ['alpha']
    }.mixed_receiver_pattern_values_with_method_generic[bool]('fallback', true)
    assert direct == 7
    assert item == 'alpha'
    assert marker
    inferred_direct, inferred_item, inferred_marker := MixedReceiverPatternBox[int, []string]{
        direct: 9
        items:  []string{}
    }.mixed_receiver_pattern_values_with_method_generic('fallback', 1.5)
    assert inferred_direct == 9
    assert inferred_item == 'fallback'
    assert inferred_marker == 1.5
}

fn test_alias_to_mixed_receiver_pattern_binds_direct_and_structured_slots() {
    direct, item, marker := MixedIntStringListBox{
        direct: 7
        items:  ['alpha']
    }.mixed_receiver_pattern_values_with_method_generic[bool]('fallback', true)
    assert direct == 7
    assert item == 'alpha'
    assert marker
    assert MixedIntStringListBox{
        direct: 1
        items:  ['alpha']
    }.same_name_with_method_generic_prefers_concrete_mixed_receiver[bool](true) == 'concrete'
}

fn test_exact_mixed_receiver_method_with_method_generic_takes_precedence_over_structured_pattern() {
    assert MixedReceiverPatternBox[int, []string]{
        direct: 1
        items:  ['alpha']
    }.same_name_with_method_generic_prefers_concrete_mixed_receiver[bool](true) == 'concrete'
    assert MixedReceiverPatternBox[int, []bool]{
        direct: 1
        items:  [true]
    }.same_name_with_method_generic_prefers_concrete_mixed_receiver[string]('marker') == 'pattern'
}

fn test_map_receiver_pattern_binds_nested_value_type() {
    assert ReceiverPatternExpect[map[string]map[string]int]{
        value: {
            'outer': {
                'inner': 7
            }
        }
    }.map_receiver_pattern_returns_existing_or_default('outer', {
        'default': 0
    })['inner'] == 7
}