modo idiomatico per implementare funzioni generiche in Go

Question

Diciamo che voglio scrivere una funzione per verificare se un predicato è abbinato un elemento in una fetta:

func IsIn(array []T, pred func(elt T) bool) bool { 
    for _, obj := range array { 
     if pred(obj) { return true;} 
    } 
    return false; 
} 

Ovviamente, il codice precedente non viene compilato, dal T non esiste. Posso sostituirlo con qualche interface{} come questo:

func IsIn(array[]interface{}, pred func(elt interface{}) bool) bool { 
    ... 
} 

Come io sono felice di lasciare il predicato eseguire il casting:

IsIn([]interface{}{1,2,3,4}, func(o interface{}) {return o.(int) == 3; }); 

Ma poi, la funzione non accetta qualsiasi matrice che non è di tipo []interface{}:

IsIn([]int{1,2,3,4}, func(o interface{}) { return o.(int) == 3; }) // DO NOT COMPILE 

E allo stesso modo:

func IsIn(arr interface, pred func(o interface{}) bool) bool { 
    for _, o := range arr.([]interface{}) { ... } 
} 
IsIn([]int{1,2,3,4}, func(o interface{}) { return o.(int) == 3; }) // PANICS AT RUNTIME (cannot cast []int to []interface) 

L'altra alternativa è quella di avere funzioni digitato per ogni tipo di matrice:

IsInInt(arr []int, pred func(i int) bool) { ... } 
IsInStr(arr []string, pred func(s string) bool) { ... } 
... 

Ma sembra molto codice duplicazione.

Qualcuno ha escogitato un bel modo per gestire tali situazioni?

EDIT

Grazie alla jnml 'fantastici suggerimenti s su Go riflessione, penso di aver trovato un bel modo per esprimere questi modelli, convertendo ogni 'iterabile' a un canale:

func iter(obj interface{}) chan interface{} { 
    c := make(chan interface{}) 
    v := reflect.ValueOf(obj) 
    if (v.Kind() == reflect.Array || v.Kind() == reflect.Slice) { 
     go func() { 
      for i := 0; i < v.Len(); i++ { 
       c<-v.Index(i).Interface() 
      } 
      close(c) 
     }() 
    } else if v.Kind() == reflect.Chan { 
     go func() { 
      x, ok := v.Recv() 
      for ok { 
       c<-x.Interface() 
       x,ok = v.Recv() 
      } 
      close(c) 
     }() 
    } else if (... whatever iteration protocol you have ...) { 
    } else { 
     panic("Cannot iterate !") 
    } 
    return c; 
} 

Con il mio esempio iniziale riscritto usandolo on the playground.

Grazie mille a jnml e ANisus per dare una mano!

Answer 1

Ad esempio:

package main 

import (
     "fmt" 
     "reflect" 
) 

func checkSlice(slice interface{}, predicate func(reflect.Value) bool) bool { 
     v := reflect.ValueOf(slice) 
     if v.Kind() != reflect.Slice { 
       panic("not a slice") 
     } 

     for i := 0; i < v.Len(); i++ { 
       if predicate(v.Index(i)) { 
         return true 
       } 
     } 

     return false 
} 

func main() { 
     a := []int{1, 2, 3, 4, 42, 278, 314} 
     fmt.Println(checkSlice(a, func(v reflect.Value) bool { return v.Int() == 42 })) 

     b := []float64{1.2, 3.4, -2.5} 
     fmt.Println(checkSlice(b, func(v reflect.Value) bool { return v.Float() > 4 })) 
} 

Playground

---

uscita:

true 
false 

Answer 2

Non posso dire se è lo più idiomatico. Ma una soluzione idiomatica sarebbe come fare nel pacchetto sort; per definire un'interfaccia per l'array:

type Interface interface { 
    Len() int 
    Equal(i int, v interface{}) bool 
} 

func IsIn(array Interface, value interface{}) bool { 
    for i := 0; i < array.Len(); i++ { 
    if array.Equal(i, value) { 
      return true 
     } 
    } 
    return false; 
} 

Fintanto che l'array implementa questa interfaccia, è possibile utilizzare IsIn().

esempio di lavoro può trovò here