How to represent currency in Go?

I'd say a way to go is to store amounts of money using properly sized integer type, normalized to the lowest possible amount. Say, if you need to store amounts in US dollars down to one cent, multiply your values by 100 and hence store them in full cents.

Another way is to implement a custom type which would model what is "decimal" in some other languages, that is, it would use two integer numbers to represent amount of money.

There are actually a few packages implementing a decimal type, though there's no clear leader among them.

Rational numbers are quite a good solution for representing money values. That is, a type that has a numerator and a denominator.

Often monetary data structures are overly complex - Java's BigDecimal being an example. A more mathematically-consistent approach is to define a type that handles rational numbers. When 64bit integers are used, a huge range of numbers can be accurately and efficiently represented. Errors and rounding issues are less of a problem than for any solution that needs to convert binary fractions to/from decimal fractions.

Edit: The Go standard library includes arbitrary-precision integers and rational numbers. The Rat type will work well for currency, especially for those cases that require arbitrary precision, e.g. foreign exchange. Here's an example.

Edit 2: I have used the decimal.Decimal Shopspring package extensively. Under the hood, this combines big.Int with an exponent to provide a fixed-point decimal with a nearly-unlimited range of values. The Decimal type is a rational number where the denominator is always a power of ten, which works very well in practice.

This seems like a great opportunity to create a type, which stores the value in a safe and precise integer-based way, but gives you extra behavior you'd want from a decimal type. For instance, a quick implementation might look like this (https://play.golang.org/p/nYbLiadQOc):

// USD represents US dollar amount in terms of cents
type USD int64

// ToUSD converts a float64 to USD
// e.g. 1.23 to $1.23, 1.345 to $1.35
func ToUSD(f float64) USD {
    return USD((f * 100) + 0.5)
}

// Float64 converts a USD to float64
func (m USD) Float64() float64 {
    x := float64(m)
    x = x / 100
    return x
}

// Multiply safely multiplies a USD value by a float64, rounding
// to the nearest cent.
func (m USD) Multiply(f float64) USD {
    x := (float64(m) * f) + 0.5
    return USD(x)
}

// String returns a formatted USD value
func (m USD) String() string {
    x := float64(m)
    x = x / 100
    return fmt.Sprintf("$%.2f", x)
}

The given type behaves the way one might expect, especially given tricky use-cases.

fmt.Println("Product costs $9.09. Tax is 9.75%.")

f := 9.09
t := 0.0975
ft := f * t
fmt.Printf("Floats: %.18f * %.18f = %.18f\n", f, t, ft)

u := ToUSD(9.09)
ut := u.Multiply(t)
fmt.Printf("USD:    %v * %v = %v\n", u, t, ut)

Product costs $9.09. Tax is 9.75%.

Floats: 9.089999999999999858 * 0.097500000000000003 = 0.886275000000000035

USD: $9.09 * 0.0975 = $0.89