Golang

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	fmt.Println("My favorite number is", rand.Intn(10))
}

import "fmt"

import f "fmt"

package main

import f "fmt"

func main() {
	f.Println("hi")
}

`fmt.Println(math.pi)` // error
`fmt.Println(math.Pi)` // correct

func NAME ( [ARGs] ) [TYPE[,...] ] { // <-mohem

}


// ERROR:
func NAME ( [ARGs] ) [TYPE[,...] ]
{

}

func add(x int, y int) int {
func add(x    , y int) int {
	return x + y
}

 package main

import "fmt"

func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	a, b := swap("hello", "world")
	fmt.Println(a, b)
}

package main

import "fmt"

func split(sum int) (x, y int) {
	x = sum * 4 / 9
	y = sum - x
	return
}

func main() {
	fmt.Println(split(17))
}

// OUTPUT:
// 7 10

package main

import (
	"fmt"
)

func main() {
	fmt.Println("Hello"); fmt.Println("World!")
}

package main

import "fmt"

//−−−−−−−−−−

var c, python, java bool

func main() {
	var i int
	fmt.Println(i, c, python, java)
}

//−−−−−−−−−−

var i, j int = 1, 2

func main() {
	var c, python, java = true, false, "no!"
	fmt.Println(i, j, c, python, java)
}

//−−−−−−−−

func main() {
	var i, j int = 1, 2
	k := 3
	c, python, java := true, false, "no!"

	fmt.Println(i, j, k, c, python, java)
}

//−−−−−−−

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32
     // represents a Unicode code point

float32 float64

complex64 complex128

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

// Or, put more simply:

i := 42
f := float64(i)
u := uint(f)

const Pi = 3.14

for i := 0; i < 10; i++ {
	sum += i
}

//---------

sum := 1
for ; sum < 1000; {
	sum += sum
}

//---------

//WHILE

sum := 1
for sum < 1000 {
	sum += sum
}

//--------

// Forever

for {
}	

if x < 0 {
	return sqrt(-x) + "i"
}

/// ELSE

if x {
	//
} else {
	//
}

if v := math.Pow(x, n); v < lim {
	return v
}

fmt.Print("Go runs on ")
switch os := runtime.GOOS; os {
case "darwin":
	fmt.Println("OS X.")
case "linux":
	fmt.Println("Linux.")
default:
	// freebsd, openbsd,
	// plan9, windows...
	fmt.Printf("%s.\n", os)
}

switch i {
case 0:
case f():
}

// does not call f if i==0.) 

func main() {
	defer fmt.Println("world")

	fmt.Println("hello")
}

//−−−−−−−

for i := 0; i < 10; i++ {
	defer fmt.Println(i)
}
// ۹ ۸ ۷ ۶ ۵ ۴ ....

var u int
var j *int

j = &u
*j = 12

fmt.Println(  u ) // 12
fmt.Println( *j ) // 12

type Vertex struct {
	X int
	Y int
}

fmt.Println(Vertex{1, 2}) // {1 2}

v := Vertex{1, 2}
v.X = 4
fmt.Println(v) // {4 2}

s := []struct {
	i int
	b bool
}

type Book struct {
	title, author string
	pages         int
}

var _ = Book {
	author: "Tapir",
	pages: 256,
	title: "Go 101", // here, the "," must be present
}

// The last "," in the following line is optional.
var _ = Book{author: "Tapir", pages: 256, title: "Go 101",}

package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	p := &v
	p.X = 1e9 // <= (*p).X
	fmt.Println(v)
}

package main

import "fmt"

type Vertex struct {
	X, Y int
}

var (
	v1 = Vertex{1, 2}  // has type Vertex
	v2 = Vertex{X: 1}  // Y:0 is implicit
	v3 = Vertex{}      // X:0 and Y:0
	p  = &Vertex{1, 2} // has type *Vertex
)

func main() {
	fmt.Println(v1, p, v2, v3)
}
//{1 2} &{1 2} {1 0} {0 0}

var a [10]int

var a [2]string
a[0] = "Hello"
a[1] = "World"

primes := [6]int{2, 3, 5, 7, 11, 13}

package main

import "fmt"

func main() {
	primes := [6]int{2, 3, 5, 7, 11, 13}

	var s []int = primes[1:4]
	fmt.Println(s)
}

a[low : high]

primes := [6]int{2, 3, 5, 7, 11, 13}

var s []int = primes[1:4]
s[1] = 120 // change prime

package main

import "fmt"

func main() {
	q := []int{2, 3, 5, 7, 11, 13}
	fmt.Println(q)

	r := []bool{true, false, true, true, false, true}
	fmt.Println(r)

	s := []struct {
		i int
		b bool
	}{
		{2, true},
		{3, false},
		{5, true},
		{7, true},
		{11, false},
		{13, true},
	}
	fmt.Println(s)
}

a[0:10]
a[:10]
a[0:]
a[:]

var s []int

 package main

 import "fmt"


 func main() {

     var arrayOfCharacter = [11] string { "s","l","i","c","e"," ","t","h","i","s","!" }

 

     sliceOfCharacter := arrayOfCharacter[6:8]

 

     fmt.Println("Capacity of array :", cap(arrayOfCharacter))

     fmt.Println("Lenght   of array :", cap(arrayOfCharacter))

     fmt.Println()

     fmt.Println("Capacity of slice :", cap(sliceOfCharacter))

     fmt.Println("Lenght   of slice :", len(sliceOfCharacter))

 }

b := make([]int, 0, 5) // len(b)=0, cap(b)=5

board := [][]string{
	[]string{"_", "_", "_"},
	[]string{"_", "_", "_"},
	[]string{"_", "_", "_"},
}

// The players take turns.
board[0][0] = "X"
board[2][2] = "O"
board[1][2] = "X"
board[1][0] = "O"
board[0][2] = "X"

var s []int
s = append(s, 0)

package main

import "fmt"

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
	for i, v := range pow {
		fmt.Printf("2**%d = %d\n", i, v)
	}
}

pow := make([]int, 10)

for i, _ := range pow
for _, value := range pow
for i := range pow

map[ KEY_TYPE ] VALUE_TYPE


/// ERROR

var m map[string]Vertex
//m = make(map[string]Vertex)
m["Bell Labs"] = Vertex{
	40.68433, -74.39967,
}

/// CORRECT

var m map[string]Vertex
m = make(map[string]Vertex)
m["Bell Labs"] = Vertex{
	40.68433, -74.39967,
}

/// CORRECT (without use var)

m := make(map[string]Vertex)
m["Bell Labs"] = Vertex{
	40.68433, -74.39967,
}

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

var m = map[string]Vertex{
	"Bell Labs": Vertex{
		40.68433, -74.39967,
	},
	"Google": Vertex{
		37.42202, -122.08408,
	},
}

/*
If the top-level type is just a type name, you can omit it from the elements of the literal. 

var m = map[string]Vertex{
	"Bell Labs": {40.68433, -74.39967},
	"Google":    {37.42202, -122.08408},
}
*/

func main() {
	fmt.Println(m)
}

elem, ok = m[key]

delete(m, "Answer")
fmt.Println("The value:", m["Answer"])

v, ok := m["Answer"]
fmt.Println("The value:", v, "Present?", ok)

/*
The value: 0
The value: 0 Present? false
*/

 package main

import (
	"fmt"
	"math"
)

func compute(fn func(float64, float64) float64) float64 {
	return fn(3, 4)
}

func main() {
	hypot := func(x, y float64) float64 {
		return math.Sqrt(x*x + y*y)
	}
	fmt.Println(hypot(5, 12))

	fmt.Println(compute(hypot))
	fmt.Println(compute(math.Pow))
}

//--------------

package main

import "fmt"

func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return sum
	}
}

func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}