inference.go

     1  // -lang=go1.20
     2  
     3  // Copyright 2021 The Go Authors. All rights reserved.
     4  // Use of this source code is governed by a BSD-style
     5  // license that can be found in the LICENSE file.
     6  
     7  // This file shows some examples of type inference.
     8  
     9  package p
    10  
    11  type Ordered interface {
    12  	~int | ~float64 | ~string
    13  }
    14  
    15  func min[T Ordered](x, y T) T { panic(0) }
    16  
    17  func _() {
    18  	// min can be called with explicit instantiation.
    19  	_ = min[int](1, 2)
    20  
    21  	// Alternatively, the type argument can be inferred from
    22  	// one of the arguments. Untyped arguments will be considered
    23  	// last.
    24  	var x int
    25  	_ = min(x, x)
    26  	_ = min(x, 1)
    27  	_ = min(x, 1.0)
    28  	_ = min(1, 2)
    29  	_ = min(1, 2.3)
    30  
    31  	var y float64
    32  	_ = min(1, y)
    33  	_ = min(1.2, y)
    34  	_ = min(1.2, 3.4)
    35  	_ = min(1.2, 3)
    36  
    37  	var s string
    38  	_ = min(s, "foo")
    39  	_ = min("foo", "bar")
    40  }
    41  
    42  func mixed[T1, T2, T3 any](T1, T2, T3) {}
    43  
    44  func _() {
    45  	// mixed can be called with explicit instantiation.
    46  	mixed[int, string, bool](0, "", false)
    47  
    48  	// Alternatively, partial type arguments may be provided
    49  	// (from left to right), and the other may be inferred.
    50  	mixed[int, string](0, "", false)
    51  	mixed[int](0, "", false)
    52  	mixed(0, "", false)
    53  
    54  	// Provided type arguments always take precedence over
    55  	// inferred types.
    56  	mixed[int, string](1.1 /* ERROR "cannot use 1.1" */, "", false)
    57  }
    58  
    59  func related1[Slice interface{ ~[]Elem }, Elem any](s Slice, e Elem) {}
    60  
    61  func _() {
    62  	// related1 can be called with explicit instantiation.
    63  	var si []int
    64  	related1[[]int, int](si, 0)
    65  
    66  	// Alternatively, the 2nd type argument can be inferred
    67  	// from the first one through constraint type inference.
    68  	var ss []string
    69  	_ = related1[[]string]
    70  	related1[[]string](ss, "foo")
    71  
    72  	// A type argument inferred from another explicitly provided
    73  	// type argument overrides whatever value argument type is given.
    74  	related1[[]string](ss, 0 /* ERROR "cannot use 0" */)
    75  
    76  	// A type argument may be inferred from a value argument
    77  	// and then help infer another type argument via constraint
    78  	// type inference.
    79  	related1(si, 0)
    80  	related1(si, "foo" /* ERROR `cannot use "foo"` */)
    81  }
    82  
    83  func related2[Elem any, Slice interface{ []Elem }](e Elem, s Slice) {}
    84  
    85  func _() {
    86  	// related2 can be called with explicit instantiation.
    87  	var si []int
    88  	related2[int, []int](0, si)
    89  
    90  	// Alternatively, the 2nd type argument can be inferred
    91  	// from the first one through constraint type inference.
    92  	var ss []string
    93  	_ = related2[string]
    94  	related2[string]("foo", ss)
    95  
    96  	// A type argument may be inferred from a value argument
    97  	// and then help infer another type argument via constraint
    98  	// type inference. Untyped arguments are always considered
    99  	// last.
   100  	related2(1.2, []float64{})
   101  	related2(1.0, []int{})
   102  	related2 /* ERROR "Slice (type []int) does not satisfy interface{[]Elem}" */ (float64(1.0), []int{}) // TODO(gri) better error message
   103  }
   104  
   105  type List[P any] []P
   106  
   107  func related3[Elem any, Slice []Elem | List[Elem]]() Slice { return nil }
   108  
   109  func _() {
   110  	// related3 can be instantiated explicitly
   111  	related3[int, []int]()
   112  	related3[byte, List[byte]]()
   113  
   114  	// The 2nd type argument cannot be inferred from the first
   115  	// one because there's two possible choices: []Elem and
   116  	// List[Elem].
   117  	related3 /* ERROR "cannot infer Slice" */ [int]()
   118  }
   119  
   120  func wantsMethods[P interface {
   121  	m1(Q)
   122  	m2() R
   123  }, Q, R any](P) {
   124  }
   125  
   126  type hasMethods1 struct{}
   127  
   128  func (hasMethods1) m1(int)
   129  func (hasMethods1) m2() string
   130  
   131  type hasMethods2 struct{}
   132  
   133  func (*hasMethods2) m1(int)
   134  func (*hasMethods2) m2() string
   135  
   136  type hasMethods3 interface {
   137  	m1(float64)
   138  	m2() complex128
   139  }
   140  
   141  type hasMethods4 interface {
   142  	m1()
   143  }
   144  
   145  func _() {
   146  	// wantsMethod can be called with arguments that have the relevant methods
   147  	// and wantsMethod's type arguments are inferred from those types' method
   148  	// signatures.
   149  	wantsMethods(hasMethods1{})
   150  	wantsMethods(&hasMethods1{})
   151  	wantsMethods /* ERROR "P (type hasMethods2) does not satisfy interface{m1(Q); m2() R} (method m1 has pointer receiver)" */ (hasMethods2{})
   152  	wantsMethods(&hasMethods2{})
   153  	wantsMethods(hasMethods3(nil))
   154  	wantsMethods /* ERROR "P (type any) does not satisfy interface{m1(Q); m2() R} (missing method m1)" */ (any(nil))
   155  	wantsMethods /* ERROR "P (type hasMethods4) does not satisfy interface{m1(Q); m2() R} (wrong type for method m1)" */ (hasMethods4(nil))
   156  }
   157  
   158  // "Reverse" type inference is not yet permitted.
   159  
   160  func f[P any](P) {}
   161  
   162  // This must not crash.
   163  var _ func(int) = f // ERROR "implicitly instantiated function in assignment requires go1.21 or later"
   164
View as plain text