go 1.17 发布，即将正式支持泛型

函数名1<T> (参数名1: T, 参数名2：参数类型): 返回值类型 {
     return ...
}
函数名2<T> (参数名1: T, 参数名2：参数类型): T {
     return ...
}
类1<T> {
    属性1 T;
    属性2 string
    方法1(参数: T): 返回值类型 { return ... }
    方法2(参数): T { return ...}
}

// https://go2goplay.golang.org/
package main

import (
    "fmt"
)

// The playground now uses square brackets for type parameters. Otherwise,
// the syntax of type parameter lists matches the one of regular parameter
// lists except that all type parameters must have a name, and the type
// parameter list cannot be empty. The predeclared identifier "any" may be
// used in the position of a type parameter constraint (and only there);
// it indicates that there are no constraints.

func Print[T any](s []T) {
    for _, v := range s {
        fmt.Print(v)
    }
}

func main() {
    Print([]string{"Hello, ", "playground\n"})
}

d:\projects\go\examples\generic
λ go version
go version go1.17 windows/amd64

d:\projects\go\examples\generic
λ go run hello.go
# command-line-arguments
.\hello.go:14:6: missing function body
.\hello.go:14:11: syntax error: unexpected [, expecting (

d:\projects\go\examples\generic
λ go run --gcflags=-G=3 hello.go
# command-line-arguments
.\hello.go:14:6: internal compiler error: Cannot export a generic function (yet): Print

Please file a bug report including a short program that triggers the error.
https://golang.org/issue/new

d:\projects\go\examples\generic
λ go run --gcflags=-G=3 hello.go
Hello, playground

// Hello.java
public class Hello
{
   // 泛型方法 print                         
   public static < E > void print( E[] input )
   {
      // 输出数组元素            
         for ( E e : input ){        
            System.out.printf( "%s ", e );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        System.out.println( "java 泛型示例: " );

        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型: " );
        print( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n字符型: " );
        print( charArray ); // 传递一个字符型数组
    } 
}

~/Projects/go/examples/generic
➜  javac Hello.java && java Hello
java 泛型示例:
整型:
1 2 3 4 5

字符型:
H E L L O

// https://www.runoob.com/cplusplus/cpp-templates.html
// hello.cpp
#include <iostream>
#include <string>
 
using namespace std;
 
template <typename T>
inline T const& Max (T const& a, T const& b) 
{ 
    return a < b ? b:a; 
} 
int main ()
{
    cout << "C++ 泛型示例" << endl; 
 
    int i = 39;
    int j = 20;
    cout << "Max(i, j): " << Max(i, j) << endl; 
 
    double f1 = 13.5; 
    double f2 = 20.7; 
    cout << "Max(f1, f2): " << Max(f1, f2) << endl; 
 
    string s1 = "Hello"; 
    string s2 = "World"; 
    cout << "Max(s1, s2): " << Max(s1, s2) << endl; 
 
   return 0;
}

fn main() {

    println!("rust 泛型示例");
    
    let i = 39;
    let j = 20;
    println!("max(i,j): {}", max(i,j));

    let s1 = "Hello"; 
    let s2 = "World"; 
    println!("max(s1,s2): {}", max(s1,s2));
}
// https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods
fn max<T: std::cmp::PartialOrd>(a: T, b :T) -> T {
    if a < b {
        return b
    } else {
        return a
    }
}

~/Projects/go/examples/generic
➜  rustc hello.rs -o hello_rs && ./hello_rs
rust 泛型示例
max(i,j): 39
max(s1,s2): World

function Max<T>(a: T, b :T): T {
    return a < b ? b:a
}

function main() {
    let i = 39;
    let j = 20;
    console.log("max(i,j): ", Max(i,j))

    let s1 = "Hello"; 
    let s2 = "World"; 
    console.log("max(s1,s2): ", Max(s1,s2))
}

main()

~/Projects/go/examples/generic
➜  deno run hello.ts
Check file:///Users/youwu/Projects/go/examples/generic/hello.ts
max(i,j):  39
max(s1,s2):  World

~/Projects/go/examples/generic
➜  tsc hello.ts && node hello.js
max(i,j):  39
max(s1,s2):  World