func ParseInt(s string, base int, bitSize int) (i int64, err error)

ParseInt always returns int64.

bitSize defines the range of values.

If the value corresponding to s cannot be represented by a signed integer of the given size, err.Err = ErrRange.

http://golang.org/pkg/strconv/#ParseInt

type int int

int is a signed integer type that is at least 32 bits in size. It is a distinct type, however, and not an alias for, say, int32.

http://golang.org/pkg/builtin/#int

So int could be bigger than 32 bit in the future or on some systems like int in C.

I guess on some systems int64 might be faster than int32 because that system only works with 64-bit integers.

Here is an example of an error when bitSize is 8:

http://play.golang.org/p/_osjMqL6Nj

package main

import (
    "fmt"
    "strconv"
)

func main() {
    i, err := strconv.ParseInt("123456", 10, 8)
    fmt.Println(i, err)
}

Because 0 is an untyped constant whose default type is int, not uint64, and when doing comparison with an interface, the thing you are comparing to must be both the same type and the same value for them to be considered equal.

https://golang.org/ref/spec#Comparison_operators

The equality operators == and != apply to operands that are comparable. The ordering operators <, <=, >, and >= apply to operands that are ordered. These terms and the result of the comparisons are defined as follows:

A value x of non-interface type X and a value t of interface type T are comparable when values of type X are comparable and X implements T. They are equal if t's dynamic type is identical to X and t's dynamic value is equal to x.

If your input comes from JSON input, then it's a float64, as per the doc:

To unmarshal JSON into an interface value, Unmarshal stores one of these in the interface value:

• bool, for JSON booleans
• float64, for JSON numbers
• string, for JSON strings
• []interface{}, for JSON arrays
• map[string]interface{}, for JSON objects
• nil for JSON null

If its comes from user input, it is whatever you decided it was when you read it, so you shouldn't have any problem to get the right type.

You convert them with a type "conversion"

var a int
var b int64
int64(a) < b

When comparing values, you always want to convert the smaller type to the larger. Converting the other way will possibly truncate the value:

var x int32 = 0
var y int64 = math.MaxInt32 + 1 // y == 2147483648
if x < int32(y) {
// this evaluates to false, because int32(y) is -2147483648

Or in your case to convert the maxInt int64 value to an int, you could use

for a := 2; a < int(maxInt); a++ {

which would fail to execute correctly if maxInt overflows the max value of the int type on your system.

This is called type conversion :

Copyi := 23
var i64 int64
i64 = int64(i)