var val interface{}
//...
x, ok := val.(int)                  // an int type assertion: x is of type int 
s, ok := val.(strings.Stringer)	    // a satisfaction test: s if op type strings.Stringer and not nil if ok 

switch x := val.(type) {
case string:            // x is a string
case bool:              // x is a bool
case float32, float64:  // x is an interface{} value containing an float32 or float64
default:	
	// x is an interface{} value containing any type
}

x, ok := val.(float32,float64)	// if ok, x has dynamic type float32 or float64, otherwise it is nil

meta Float {float32,float64}    
meta Int {int,int8,int16,int32,int64}


meta {} // all types 

var val interface{} = 1
x, ok := val.(Int)	// ok = true
x, ok = val.(Float) 	// ok = false

swich x := val.(type) {
case Float:
	// x has dynamic type of any type in Float
case Int:
    // x contains and int (of any type in Int)
	// x is int
case int:
    // x is an int
}

package json

// M is the set of all types that are marshallable to JSON.
// NOTE: compare this with the description in the JSON package of marshallable types 
meta M {		
	*M,     
	bool,
	int,
	float64
	string,
	[]M,
	struct,
	Marshaller,
}

func ParseJSON(r io.Reader, dest interface{}) error {
    if _, ok := dest.(*M); !ok {
        return fmt.Errorf("dest is not a pointer or the value pointed to is not marshallable to JSON", dest)
    }
    ... // use type switching (and package reflect for structs) for rest of implementation
}

meta T {}

// a generic struct: it uses the meta type T in its field definitions
type ListNode struct {
	prev *ListNode 
	next *ListNode 
	Payload T
}

type MyGenericChannel chan T

meta K (==)
meta V {}
type Pair struct {         
    Key K 
    Value V
}

type HashTable struct {
    Table []Pair(K,V)
    HashFn func(value V) int    
}   

// same definition of the generic Pair type but with explicit meta type signature (K,V)
type Pair(K,V) struct {      
    Key K 
    Value V
}

// Min is a generic function with a meta type signature (T) consisting of a single meta type T
func Min(T)(a T, b T) T {...}	        // (T) is the explicit meta signature.

// these declarations all define the same generic function type 
type MinFn(T) func(a, b T)              // meta signature (T) is inferred here automatically
type MinFn func(a, b T) 

func DotProduct(a, b Vector(T)) T       // meta signature (T) is inferred here automatically
func DotProduct(T)(a, b Vector(T)) T    // explicit meta sig (T)

func FanIn(chans []chan T) chan T  {...}

// example with multi meta types
func Keys(m map[K]V) []K {...}          // meta signature (K,V) is inferred here automatically
func Keys(K,V)(m map[K]V) []K {...}     // same thing but with an explicit meta type signature.

// struct examples
type LiseNode(T) struct {               // explicit meta signature
    prev *ListNode 
    	next *ListNode 
    	Payload T
}

type Bimap(K,V) struct {		// meta type signature (K,V) is required here - see below
	forward map[K]V
	reverse map[K]V
}

func (b *Bimap) GetValueByKey(key K) V {
    return b.foward[key]
} 

func (b *Bimap(K,V)) GetKeyByValue(value Value) V { // ok - but not needed
    return b.reverse[value]
} 

meta T {K}

func (b *Bimap(T,V)) GetKeyByValue(value Value) V { // error - illegal type signature (T,V) (expected (K,V)
    return b.reverse[value]
} 
 

package stats
meta T {int,float32,float64}

func Sum(a, b T) T {
	return a + b
}

stats.fsum(1, 1)                    // ok - T is inferred to type int
stats.fsum(1.0, 1.0)                // ok - T is inferred to type float64
stats.fsum(float32)(1.0, 1.0)       // ok - T is explicitly set to type float64

node := ListNode{Payload: "Gophers!"}                   // ok - T is inferred to type string
var node ListNode(string)                               // ok - T is explicitly set
type MyNode ListNode(string)                            // ok - MyNode has type struct { ..., Payload string }

stats.Sum("go", "c++")              // compile error: type string is not in stats.T
stats.Sum(byte)                     // compile error: type byte is not in stats.T

meta S {io.Reader}
fund MyReader(val S) {...}

stringReader := MyReader(string)        // compile error: string does not satisfy io.Reader
fileReader := MyReader(file)            // ok - fileReader has type func(*os.File)

stats.Sum(1, 1.0)                   // compile error: attempt to bind stats.T to both int and float64.

fsum := stats.Sum                   // compile error: no type is provided for stats.T
fsum := stats.Sum(float64)          // ok - fsum is a function with signature (a, b float64) float64

meta T {}
meta C {<}

func Max(a, b T) T {
    if a > b {		// compile error: operator < is not supported by all types in T
        return b
    }
    return a
}
          
func Min(a, b C) C {
    if a < b {		// ok - all types in C support < operator (as per its definition)
        return b
    }
    return a
}

func Max(a, b C) C {
    if a > b {		// also fine: the compiler knows that all types that support <, also support >
        return b
    }
    return a
}

func MyFunc(val C) {
        val.String()  // compile error: method String is not supported by all types in C 
}

meta S {fmt.Stringer}  // S is the set of all types that satisfy interface fmt.Stringer 
func Concat(values []S) string {
    var result s
    for _, v := range values {
        s += v.String()         // ok
    }    
    return s 
}

type interface One { 
    A()
    B()
}

type interface Two { 
    B()
    C()
}

meta Q {One,Two}    

func contrived(q Q) {
    q.B()               // ok: all types in Q have B
    q.A()               // compile error: A() is not supported by all types in Q
}

package sql
meta R {struct} 

// ScanRow uses generics only to provide a type safe function signature 
func ScanRow(row *sql.Row, dest *R) error {
	return scanRow(row, dest)	// scanRow is the non-generic implementation, separated out to prevent unnecessary code duplication.
}

var person Person
sql.ScanRow(r, person)	// compile error: argument person of type Person is not of meta type *sql.R
sql.ScanRow(r, &person)	// ok

var count int
sql.ScanRow(r, &count)	// compile error: argument count of type *int is not of meta type *sql.R

// package json
// M is the set of all types that are marshallable to JSON.
meta M {		
	*M,     
	bool,
	int,
	float64
	string,
	[]M,
	struct,
	Marshaller,
}

func Unmarshall(r io.Reader, dest *M) error { // type safe interface
    return parse(r, m) // function parse is not generic and is implemented using reflection
}

json.Unmarshall(..., person)    // compile error -  person (type Person) is not of meta type *json.Marshallable
json.Unmarshall(..., &person)   // ok

c := make(chan int)
json.Unmarshall(..., &c)       // compile error - c (type chan int) is not of meta type *json.Marshallable c

package linalg 

// Field is an interface to types that support arithmetic using +,-,* and /.
// NOTE: big.Int/Rat/Float could implement Field
type Field interface {
	// in the field operations below, f is the right operand
	AddField(f Field) Field
	SubField(f Field) Field
	MultField(f Field) Field
	DivField(f Field) Field
}

meta N {types.Ints,types.Float,types.Complex} 
meta T {N,Field}

type Vector {
	Elems []T
}

func DotProduct(a, b Vector(T)) T {
    var result T
    for i := range len(a.Elems) {

        // compile different code depending on type
        compile T.(type) {
        case Field: 
            // code in this block is included only for types that satisfy Field
			
            prod := a.Elems[i].MultField(b.Elems[i])
            result = result.AddField(prod).(T)  

        case N: 
            // code is included for types in N
            result += a.elems[i] * b.elems[i]
        }
    }
    return result
}

func (* Matrix) Mult(other Matrix(T)) Matrix(T) {
    // compile blocks are against used to provide (optimized) implementation
}

// package goclapack
import la "math.linalg"

type N {float64,float32,complex64,complex128}

func SVD(m la.Matrix(N)) (la.Matrix(N), la.Matrix(N), la.Matrix(N), error) {
	s := m la.NewMatrix(N)(...)
    v := m la.NewMatrix(N)(...)
    d := m la.NewMatrix(N)(...)
    
    var err error

    // compile blocks used to call correct routine directly on the elements in matrix m, s,v and d.
    compile N.(type) {
    case float32:
    	C.fgesvd('A', 'A', c.size_t(m.rows), c.size_t(m.cols), unsafe.Pointer(&m.elem[0]))
        // detect err
        err = ...
    case float64:
        C.dgesvd('A', 'A', c.size_t(m.rows), c.size_t(m.cols), unsafe.Pointer(&m.elem[0]))
    
    // etc
    }
    
    return s, v, d, err

}