test/typeparam/cons.go

   1 // run
   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 package main
   8
   9 import "fmt"
  10
  11 // Overriding the predeclare "any", so it can be used as a type constraint or a type
  12 // argument
  13 type any interface{}
  14
  15 type Function[a, b any] interface {
  16         Apply(x a) b
  17 }
  18
  19 type incr struct{ n int }
  20
  21 func (this incr) Apply(x int) int {
  22         return x + this.n
  23 }
  24
  25 type pos struct{}
  26
  27 func (this pos) Apply(x int) bool {
  28         return x > 0
  29 }
  30
  31 type compose[a, b, c any] struct {
  32         f Function[a, b]
  33         g Function[b, c]
  34 }
  35
  36 func (this compose[a, b, c]) Apply(x a) c {
  37         return this.g.Apply(this.f.Apply(x))
  38 }
  39
  40 type _Eq[a any] interface {
  41         Equal(a) bool
  42 }
  43
  44 type Int int
  45
  46 func (this Int) Equal(that int) bool {
  47         return int(this) == that
  48 }
  49
  50 type List[a any] interface {
  51         Match(casenil Function[Nil[a], any], casecons Function[Cons[a], any]) any
  52 }
  53
  54 type Nil[a any] struct {
  55 }
  56
  57 func (xs Nil[a]) Match(casenil Function[Nil[a], any], casecons Function[Cons[a], any]) any {
  58         return casenil.Apply(xs)
  59 }
  60
  61 type Cons[a any] struct {
  62         Head a
  63         Tail List[a]
  64 }
  65
  66 func (xs Cons[a]) Match(casenil Function[Nil[a], any], casecons Function[Cons[a], any]) any {
  67         return casecons.Apply(xs)
  68 }
  69
  70 type mapNil[a, b any] struct {
  71 }
  72
  73 func (m mapNil[a, b]) Apply(_ Nil[a]) any {
  74         return Nil[b]{}
  75 }
  76
  77 type mapCons[a, b any] struct {
  78         f Function[a, b]
  79 }
  80
  81 func (m mapCons[a, b]) Apply(xs Cons[a]) any {
  82         return Cons[b]{m.f.Apply(xs.Head), Map[a, b](m.f, xs.Tail)}
  83 }
  84
  85 func Map[a, b any](f Function[a, b], xs List[a]) List[b] {
  86         return xs.Match(mapNil[a, b]{}, mapCons[a, b]{f}).(List[b])
  87 }
  88
  89 func main() {
  90         var xs List[int] = Cons[int]{3, Cons[int]{6, Nil[int]{}}}
  91         var ys List[int] = Map[int, int](incr{-5}, xs)
  92         var xz List[bool] = Map[int, bool](pos{}, ys)
  93         cs1 := xz.(Cons[bool])
  94         cs2 := cs1.Tail.(Cons[bool])
  95         _, ok := cs2.Tail.(Nil[bool])
  96         if cs1.Head != false || cs2.Head != true || !ok {
  97                 panic(fmt.Sprintf("got %v, %v, %v, expected false, true, true",
  98                         cs1.Head, cs2.Head, ok))
  99         }
 100 }