Why does %T not print the type of my constant?

Question

I'm just learning golang using the official tour/tutorial. In one of the examples, I see a note that says An untyped constant takes the type needed by its context.

I'm trying this:

package main

import "fmt"

const (
    // Create a huge number by shifting a 1 bit left 100 places.
    // In other words, the binary number that is 1 followed by 100 zeroes.
    Big = 1 << 100
)

func main() {
    fmt.Printf("Big is of type %T\n", Big)
}

But this fails when I run it, with:

# command-line-arguments
./compile63.go:12:13: constant 1267650600228229401496703205376 overflows int

Why am I unable to discover the type of the constant this way? (Please note I'm a total noob and quite possibly haven't yet discovered enough about the language to be able to solve this myself).

Go is really good at catching errors before ever running the code, and that's what's happening here. Until you fix it, it wont compile — Derek Pollard, Jun 20 '18 at 06:10
@Derek: The type `int64` cannot accommodate a number that big. — Azeem, Jun 20 '18 at 06:29
See related / possible duplicate [How does Go perform arithmetic on constants?](https://stackoverflow.com/questions/38982278/how-does-go-perform-arithmetic-on-constants/38982889#38982889) — icza, Jun 20 '18 at 06:40
@icza: It's not about arithmetic. It is about default types during assignment. — peterSO, Jun 20 '18 at 06:54
Read about constants in Go here: https://blog.golang.org/constants — Volker, Jun 20 '18 at 09:56

peterSO · Answer 1 · 2018-06-20T16:09:32.323

func Printf
func Printf(format string, a ...interface{}) (n int, err error)
Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

The Go Programming Language Specification

Variable declarations

A variable declaration creates one or more variables, binds corresponding identifiers to them, and gives each a type and an initial value.

If a list of expressions is given, the variables are initialized with the expressions following the rules for assignments. Otherwise, each variable is initialized to its zero value.

If a type is present, each variable is given that type. Otherwise, each variable is given the type of the corresponding initialization value in the assignment. If that value is an untyped constant, it is first converted to its default type; if it is an untyped boolean value, it is first converted to type bool. The predeclared value nil cannot be used to initialize a variable with no explicit type.

Constants

Constants may be typed or untyped. Literal constants, true, false, iota, and certain constant expressions containing only untyped constant operands are untyped.

A constant may be given a type explicitly by a constant declaration or conversion, or implicitly when used in a variable declaration or an assignment or as an operand in an expression. It is an error if the constant value cannot be represented as a value of the respective type.

An untyped constant has a default type which is the type to which the constant is implicitly converted in contexts where a typed value is required, for instance, in a short variable declaration such as i := 0 where there is no explicit type. The default type of an untyped constant is bool, rune, int, float64, complex128 or string respectively, depending on whether it is a boolean, rune, integer, floating-point, complex, or string constant.

Numeric types

A numeric type represents sets of integer or floating-point values. Some predeclared architecture-independent numeric types:
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)
The value of an n-bit integer is n bits wide and represented using two's complement arithmetic.

There are also some predeclared numeric types with implementation-specific sizes:
uint     either 32 or 64 bits
int      same size as uint

Big is an untyped constant. There is no type to discover. It is given a type when used in a variable or assignment. The default type for the untyped constant Big is int.

const Big = 1 << 100

In Go, all arguments are passed by value as if by assignment. For fmt.Printf, the second argument is of type interface{}. Therefore, equivalently,

var arg2 interface{} = Big  // constant 1267650600228229401496703205376 overflows int
fmt.Printf("Big is of type %T\n", arg2)

The default type for an untyped integer constant is int. Overflow is a compile-time error.

For example,

package main

import "fmt"

const (
    // Create a huge number by shifting a 1 bit left 100 places.
    // In other words, the binary number that is 1 followed by 100 zeroes.
    Big = 1 << 100
)

func main() {
    var arg2 interface{} = Big
    fmt.Printf("Big is of type %T\n", arg2)

    fmt.Printf("Big is of type %T\n", Big)
}

Playground: https://play.golang.org/p/9tynPTek3wN

Output:

prog.go:12:6: constant 1267650600228229401496703205376 overflows int
prog.go:15:13: constant 1267650600228229401496703205376 overflows int

Reference: The Go Blog: Constants

Thank you for including the reference! – Kedar Mhaswade Jul 19 '18 at 00:38 — Kedar Mhaswade, Jul 19 '18 at 00:38

score 4 · Answer 2 · answered Jun 20 '18 at 09:09

While it is true that an untyped constant takes the type needed by its context, the type it can assume is limited by the primitives of the language, so a constant that big is not actually usable anywhere in the code, due to the fact that it does not fit even in an uint64. The only use it could have would be that of using it in another constant expression, because otherwise that error will always be thrown.

Note that in Printf (and similar functions), the constant is converted to an interface{}, and thus it takes a type of int by default. For 32-bit machines, you need to do a type conversion first if you have a constant expression which overflows int32.

const i = 1 << 50
fmt.Println(i) // => constant 1125899906842624 overflows int
fmt.Println(int64(i)) // => 1125899906842624

If you want to do proper arithmetic on arbitrarily big numbers, there is a handy package: math/big.

i := big.NewInt(1)
i.Lsh(i, 100)
fmt.Println(i.String())

Playground

Why does %T not print the type of my constant?

2 Answers2