Variables, Constants and iota

package main

import (
	"fmt"

	"example.com/shelf/catalog"
)

// Package-level variables: declared with var, never with :=.
var (
	count   int
	title   string
	ratio   float64
	open    bool
	book    catalog.Book
	authors []catalog.Author
	index   map[catalog.ISBN]catalog.Book
	state   catalog.LoanState
	err     error
)

func main() {
	fmt.Printf("%d %q %v %t\n", count, title, ratio, open)
	fmt.Printf("%+v\n", book)
	fmt.Println(authors == nil, len(authors), index == nil, len(index))
	fmt.Println(state, err == nil)
	defer func() { fmt.Println("recovered:", recover()) }()
	index["x"] = book // reading a nil map is fine; writing to it panics
}

0 "" 0 false
{ISBN: Title: Authors:[]}
true 0 true 0
available true
recovered: assignment to entry in nil map

package main

import (
	"fmt"
	"time"
)

const (
	MaxLoans         = 5                   // untyped integer constant
	Fine             = 0.25                // untyped floating-point constant
	Library          = "Central"           // untyped string constant
	Grace    int64   = 3                   // typed constant: int64
	Rate     float32 = 0.5                 // typed constant: float32
	LoanTerm         = 14 * 24 * time.Hour // typed: time.Duration, from the typed time.Hour
)

func main() {
	var f float64 = MaxLoans // an untyped constant adapts to its context
	var b byte = MaxLoans
	var d time.Duration = MaxLoans * time.Second
	fmt.Println(f, b, d, LoanTerm)
	fmt.Printf("%T %T %T %T %T\n", MaxLoans, Fine, Library, Grace, LoanTerm)
	fmt.Println(MaxLoans/2, MaxLoans/2.0, Fine*MaxLoans)
}

5 5 5s 336h0m0s
int float64 string int64 time.Duration
2 2.5 1.25

package main

import "fmt"

func main() {
	// Mixing untyped constants: the result has the "larger" kind.
	// integer < rune < floating-point < complex
	fmt.Printf("%T\n", 1+'a')   // rune
	fmt.Printf("%T\n", 'a'+1.0) // float64
	fmt.Printf("%T\n", 1.0+2i)  // complex128
	fmt.Printf("%T\n", 1<<3)    // int
	x := 1 << 3.0               // 3.0 is representable as an integer: legal
	fmt.Println(x)

	// Untyped constants are exact; the conversion to a type happens last.
	const third = 1.0 / 3
	var f32 float32 = third
	var f64 float64 = third
	fmt.Println(f32, f64, float64(f32) == f64)
	fmt.Println(1/2, 1/2.0, 1.0/2, 7/2*2.0)
}

int32
float64
complex128
int
8
0.33333334 0.3333333333333333 false
0 0.5 0.5 6

package main

import "fmt"

const limit int = 5

func main() {
	var f float64 = limit
	fmt.Println(f)
}

# example.com/shelf/ref/err/const-typed-mismatch
./main.go:8:18: cannot use limit (constant 5 of type int) as float64 value in variable declaration

package main

import (
	"fmt"
	"math"
	"math/big"
)

const (
	Huge  = 1 << 100              // far beyond any integer type
	Small = Huge >> 99            // the arithmetic is exact; the result fits int
	Tiny  = 1e-300 * 1e-300       // underflows float64 if computed at run time...
	Big   = 1e300 * 1e300 / 1e300 // ...and so would this overflow
)

func main() {
	fmt.Println(Small, Huge/(1<<98))
	fmt.Println(Big, Tiny*1e600)
	fmt.Println(math.Pi*1e100/1e100 == math.Pi)

	// At run time the same arithmetic wraps or overflows.
	h := 1 << 62
	fmt.Println(h*2, h*4)

	// For arbitrary precision at run time, use math/big.
	fmt.Println(new(big.Int).Lsh(big.NewInt(1), 100))
}

2 4
1e+300 1
true
-9223372036854775808 0
1267650600228229401496703205376

package main

import "fmt"

const big = 1 << 100

func main() {
	var small int8 = 200
	fmt.Println(small)
	fmt.Println(big)
}

# example.com/shelf/ref/err/const-overflow
./main.go:8:19: cannot use 200 (untyped int constant) as int8 value in variable declaration (overflows)
./main.go:10:14: cannot use big (untyped int constant 1267650600228229401496703205376) as int value in argument to fmt.Println (overflows)

package main

import "fmt"

func main() {
	var pages int = 1.5
	var ok int = 2.0
	fmt.Println(pages, ok)
}

# example.com/shelf/ref/err/const-truncated
./main.go:6:18: cannot use 1.5 (untyped float constant) as int value in variable declaration (truncated)

package main

import "fmt"

func main() {
	const zero = 0
	fmt.Println(10 / zero)
}

# example.com/shelf/ref/err/const-div-zero
./main.go:7:19: invalid operation: division by zero

package main

import (
	"fmt"
	"time"
)

const now = time.Now()

func main() {
	const n = len([]int{1, 2})
	fmt.Println(now, n)
}

# example.com/shelf/ref/err/const-not-constant
./main.go:8:13: time.Now() (value of struct type time.Time) is not constant
./main.go:11:12: len([]int{…}) (value of type int) is not constant

package main

const MaxLoans = 5

func main() {
	MaxLoans = 6
	p := &MaxLoans
	_ = p
}

# example.com/shelf/ref/err/const-assign
./main.go:6:2: cannot assign to MaxLoans (neither addressable nor a map index expression)
./main.go:7:8: invalid operation: cannot take address of MaxLoans (untyped int constant 5)

package main

import "fmt"

// LoanState is an enumeration: a defined integer type plus named constants.
type LoanState int

const (
	Available LoanState = iota
	OnLoan
	Overdue
	numStates // unexported sentinel: the number of valid states
)

var stateNames = [...]string{Available: "available", OnLoan: "on loan", Overdue: "overdue"}

func (s LoanState) String() string {
	if s < 0 || s >= numStates {
		return fmt.Sprintf("LoanState(%d)", int(s))
	}
	return stateNames[s]
}

func (s LoanState) Valid() bool { return s >= 0 && s < numStates }

func main() {
	var s LoanState = OnLoan
	fmt.Println(s, Overdue, LoanState(7))
	fmt.Printf("%v %d %s %q %x\n", s, s, s, s, s)
	fmt.Println(LoanState(7).Valid(), Available.Valid())
	var zero LoanState
	fmt.Println(zero == Available) // the zero value is the first constant
	s = 2                          // an untyped constant converts silently
	fmt.Println(s)
}

on loan overdue LoanState(7)
on loan 1 on loan "on loan" 6f6e206c6f616e
false true
true
overdue

//go:generate stringer -type=LoanState -trimprefix=Loan
type LoanState int

package main

import (
	"fmt"
	"strings"
)

// Perm is a bit set of member permissions.
type Perm uint8

const (
	Borrow Perm = 1 << iota
	Reserve
	Renew
	Admin
	None Perm = 0
)

func (p Perm) Has(q Perm) bool { return p&q == q }

func (p Perm) String() string {
	if p == None {
		return "none"
	}
	var parts []string
	for _, f := range []struct {
		bit  Perm
		name string
	}{{Borrow, "borrow"}, {Reserve, "reserve"}, {Renew, "renew"}, {Admin, "admin"}} {
		if p.Has(f.bit) {
			parts = append(parts, f.name)
		}
	}
	return strings.Join(parts, "|")
}

func main() {
	p := Borrow | Renew
	fmt.Println(p, p.Has(Renew), p.Has(Admin), uint8(p))
	p |= Admin  // set
	p &^= Renew // clear
	fmt.Println(p, None)
	fmt.Printf("%08b %08b\n", Borrow, Admin)
}

borrow|renew true false 5
borrow|admin none
00000001 00001000

package main

import "fmt"

// Status codes are part of a wire format: never derive them from iota.
const (
	StatusOK       = 200
	StatusNotFound = 404
)

// Ordinals derived from iota change when somebody inserts a line.
const (
	Fiction = iota
	Poetry
	Drama
)

func main() {
	fmt.Println(StatusOK, StatusNotFound, Fiction, Poetry, Drama)
	// If a new genre is inserted before Poetry, Poetry and Drama silently
	// shift. A value stored in a database or file as "1" changes meaning.
}

200 404 0 1 2

package main

import "fmt"

func main() {
	var x = iota
	fmt.Println(x)
}

# example.com/shelf/ref/err/iota-outside
./main.go:6:10: cannot use iota outside constant declaration