diff options
30 files changed, 851 insertions, 0 deletions
diff --git a/content/constants.article b/content/constants.article new file mode 100644 index 0000000..fbbfbd8 --- /dev/null +++ b/content/constants.article @@ -0,0 +1,452 @@ +Constants +25 Aug 2014 +Tags: constants + +Rob Pike + +* Introduction + +Go is a statically typed language that does not permit operations that mix numeric types. +You can't add a `float64` to an `int`, or even an `int32` to an `int`. +Yet it is legal to write `1e6*time.Second` or `math.Exp(1)` or even `1<<('\t'+2.0)`. +In Go, constants, unlike variables, behave pretty much like regular numbers. +This post explains why that is and what it means. + +* Background: C + +In the early days of thinking about Go, we talked about a number of problems caused by the way C and its descendants let you mix and match numeric types. +Many mysterious bugs, crashes, and portability problems are caused by expressions that combine integers of different sizes and "signedness". +Although to a seasoned C programmer, the result of a calculation like + + unsigned int u = 1e9; + long signed int i = -1; + ... i + u ... + +may be familiar, it isn't _a_priori_ obvious. +How big is the result? +What is its value? +Is it signed or unsigned? + +Nasty bugs lurk here. + +C has a set of rules called "the usual arithmetic conversions" and it is an indicator of their subtlety that they have changed over the years (introducing yet more bugs, retroactively). + +When designing Go, we decided to avoid this minefield by mandating that there is _no_ mixing of numeric types. +If you want to add `i` and `u`, you must be explicit about what you want the result to be. +Given + + var u uint + var i int + +you can write either `uint(i)+u` or `i+int(u)`, with both the meaning and type of the addition clearly expressed, but unlike in C you cannot write `i+u`. +You can't even mix `int` and `int32`, even when `int` is a 32-bit type. + +This strictness eliminates a common cause of bugs and other failures. +It is a vital property of Go. +But it has a cost: it sometimes requires programmers to decorate their code with clumsy numeric conversions to express their meaning clearly. + +And what about constants? +Given the declarations above, what would make it legal to write `i` `=` `0` or `u` `=` `0`? +What is the _type_ of `0`? +It would be unreasonable to require constants to have type conversions in simple contexts such as `i` `=` `int(0)`. + +We soon realized the answer lay in making numeric constants work differently from how they behave in other C-like languages. +After much thinking and experimentation, we came up with a design that we believe feels right almost always, freeing the programmer from converting constants all the time yet being able to write things like `math.Sqrt(2)` without being chided by the compiler. + +In short, constants in Go just work, most of the time anyway. +Let's see how that happens. + +* Terminology + +First, a quick definition. +In Go, `const` is a keyword introducing a name for a scalar value such as `2` or `3.14159` or `"scrumptious"`. +Such values, named or otherwise, are called _constants_ in Go. +Constants can also be created by expressions built from constants, such as `2+3` or `2+3i` or `math.Pi/2` or `("go"+"pher")`. + +Some languages don't have constants, and others have a more general definition of constant or application of the word `const`. +In C and C++, for instance, `const` is a type qualifier that can codify more intricate properties of more intricate values. + +But in Go, a constant is just a simple, unchanging value, and from here on we're talking only about Go. + +* String constants + +There are many kinds of numeric constants—integers, floats, runes, signed, unsigned, imaginary, complex—so let's start with a simpler form of constant: strings. +String constants are easy to understand and provide a smaller space in which to explore the type issues of constants in Go. + +A string constant encloses some text between double quotes. +(Go has also has raw string literals, enclosed by backquotes ``````, but for the purpose of this discussion they have all the same properties.) +Here is a string constant: + + "Hello, 世界" + +(For much more detail about the representation and interpretation of strings, see [[//blog.golang.org/strings][this blog post]].) + +What type does this string constant have? +The obvious answer is `string`, but that is _wrong_. + +This is an _untyped_string_constant_, which is to say it is a constant textual value that does not yet have a fixed type. +Yes, it's a string, but it's not a Go value of type `string`. +It remains an untyped string constant even when given a name: + + const hello = "Hello, 世界" + +After this declaration, `hello` is also an untyped string constant. +An untyped constant is just a value, one not yet given a defined type that would force it to obey the strict rules that prevent combining differently typed values. + +It is this notion of an _untyped_ constant that makes it possible for us to use constants in Go with great freedom. + +So what, then, is a _typed_ string constant? +It's one that's been given a type, like this: + + const typedHello string = "Hello, 世界" + +Notice that the declaration of `typedHello` has an explicit `string` type before the equals sign. +This means that `typedHello` has Go type `string`, and cannot be assigned to a Go variable of a different type. +That is to say, this code works: + +.play -edit constants/string1.go /START/,/STOP/ + +but this does not: + +.play -edit constants/string2.go /START/,/STOP/ + +The variable `m` has type `MyString` and cannot be assigned a value of a different type. +It can only be assigned values of type `MyString`, like this: + +.play -edit constants/string3.go /START/,/STOP/ + +or by forcing the issue with a conversion, like this: + +.play -edit constants/string4.go /START/,/STOP/ + +Returning to our _untyped_ string constant, it has the helpful property that, since it has no type, assigning it to a typed variable does not cause a type error. +That is, we can write + + m = "Hello, 世界" + +or + + m = hello + +because, unlike the typed constants `typedHello` and `myStringHello`, the untyped constants `"Hello, 世界"` and `hello` _have_no_type_. +Assigning them to a variable of any type compatible with strings works without error. + +These untyped string constants are strings, of course, so they can only be used where a string is allowed, but they do not have _type_ `string`. + +* Default type + +As a Go programmer, you have certainly seen many declarations like + + str := "Hello, 世界" + +and by now you might be asking, "if the constant is untyped, how does `str` get a type in this variable declaration?" +The answer is that an untyped constant has a default type, an implicit type that it transfers to a value if a type is needed where none is provided. +For untyped string constants, that default type is obviously `string`, so + + str := "Hello, 世界" + +or + + var str = "Hello, 世界" + +means exactly the same as + + var str string = "Hello, 世界" + +One way to think about untyped constants is that they live in a kind of ideal space of values, a space less restrictive than Go's full type system. +But to do anything with them, we need to assign them to variables, and when that happens the _variable_ (not the constant itself) needs a type, and the constant can tell the variable what type it should have. +In this example, `str` becomes a value of type `string` because the untyped string constant gives the declaration its default type, `string`. + +In such a declaration, a variable is declared with a type and initial value. +Sometimes when we use a constant, however, the destination of the value is not so clear. +For instance consider this statement: + +.play -edit constants/default1.go /START/,/STOP/ + +The signature of `fmt.Printf` is + + func Printf(format string, a ...interface{}) (n int, err error) + +which is to say its arguments (after the format string) are interface values. +What happens when `fmt.Printf` is called with an untyped constant is that an interface value is created +to pass as an argument, and the concrete type stored for that argument is the default type of the constant. +This process is analogous to what we saw earlier when declaring an initialized value using an untyped string constant. + +You can see the result in this example, which uses the format '%v' to print the value and `%T` to print the type of the value being passed to `fmt.Printf`: + +.play -edit constants/default2.go /START/,/STOP/ + +If the constant has a type, that goes into the interface, as this example shows: + +.play -edit constants/default3.go /START/,/STOP/ + +(For more information about how interface values work, see the first sections of [[//blog.golang.org/laws-of-reflection][this blog post]].) + +In summary, a typed constant obeys all the rules of typed values in Go. +On the other hand, an untyped constant does not carry a Go type in the same way and can be mixed and matched more freely. +It does, however, have a default type that is exposed when, and only when, no other type information is available. + +* Default type determined by syntax + +The default type of an untyped constant is determined by its syntax. +For string constants, the only possible implicit type is `string`. +For [[http://golang.org/ref/spec#Numeric_types][numeric constants]], the implicit type has more variety. +Integer constants default to `int`, floating-point constants `float64`, rune constants to `rune` (an alias for `int32`), and imaginary constants to `complex128`. +Here's our canonical print statement used repeatedly to show the default types in action: + +.play -edit constants/syntax.go /START/,/STOP/ + +(Exercise: Explain the result for `'x'`.) + +* Booleans + +Everything we said about untyped string constants can be said for untyped boolean constants. +The values `true` and `false` are untyped boolean constants that can be assigned to any boolean variable, +but once given a type, boolean variables cannot be mixed: + +.play -edit constants/bool.go /START/,/STOP/ + +Run the example and see what happens, then comment out the "Bad" line and run it again. +The pattern here follows exactly that of string constants. + +* Floats + +Floating-point constants are just like boolean constants in most respects. +Our standard example works as expected in translation: + +.play -edit constants/float1.go /START/,/STOP/ + +One wrinkle is that there are _two_ floating-point types in Go: `float32` and `float64`. +The default type for a floating-point constant is `float64`, although an untyped floating-point +constant can be assigned to a `float32` value just fine: + +.play -edit constants/float2.go /START/,/STOP/ + +Floating-point values are a good place to introduce the concept of overflow, or the range of values. + +Numeric constants live in an arbitrary-precision numeric space; they are just regular numbers. +But when they are assigned to a variable the value must be able to fit in the destination. +We can declare a constant with a very large value: + +.code constants/float3.go /Huge/ + +—that's just a number, after all—but we can't assign it or even print it. This statement won't even compile: + +.play -edit constants/float3.go /Println/ + +The error is, "constant 1.00000e+1000 overflows float64", which is true. +But `Huge` might be useful: we can use it in expressions with other constants and use the value of those expressions if the result +can be represented in the range of a `float64`. +The statement, + +.play -edit constants/float4.go /Println/ + +prints `10`, as one would expect. + +In a related way, floating-point constants may have very high precision, so that arithmetic involving them is more accurate. +The constants defined in the [[//golang.org/pkg/math][math]] package are given with many more digits than are +available in a `float64`. Here is the definition of `math.Pi`: + + Pi = 3.14159265358979323846264338327950288419716939937510582097494459 + +When that value is assigned to a variable, some of the precision will be lost; the assignment will create the `float64` (or `float32`) +value closest to the high-precision value. This snippet + +.play -edit constants/float5.go /START/,/STOP/ + +prints `3.141592653589793`. + +Having so many digits available means that calculations like `Pi/2` or other more intricate evaluations can carry more precision +until the result is assigned, making calculations involving constants easier to write without losing precision. +It also means that there is no occasion in which the floating-point corner cases like infinities, +soft underflows, and `NaNs` arise in constant expressions. +(Division by a constant zero is a compile-time error, and when everything is a number there's no such thing as "not a number".) + +* Complex numbers + +Complex constants behave a lot like floating-point constants. +Here's a version of our now-familiar litany translated into complex numbers: + +.play -edit constants/complex1.go /START/,/STOP/ + +The default type of a complex number is `complex128`, the larger-precision version composed of two `float64` values. + +For clarity in our example, we wrote out the full expression `(0.0+1.0i)`, but this value can be shortened to `0.0+1.0i`, +`1.0i` or even `1i`. + +Let's play a trick. +We know that in Go, a numeric constant is just a number. +What if that number is a complex number with no imaginary part, that is, a real? +Here's one: + +.code constants/complex2.go /const Two/ + +That's an untyped complex constant. +Even though it has no imaginary part, the _syntax_ of the expression defines it to have default type `complex128`. +Therefore, if we use it to declare a variable, the default type will be `complex128`. The snippet + +.play -edit constants/complex2.go /START/,/STOP/ + +prints `complex128:` `(2+0i)`. +But numerically, `Two` can be stored in a scalar floating-point number, a `float64` or `float32`, with no loss of information. +Thus we can assign `Two` to a `float64`, either in an initialization or an assignment, without problems: + +.play -edit constants/complex3.go /START/,/STOP/ + +The output is `2` `and` `2`. +Even though `Two` is a complex constant, it can be assigned to scalar floating-point variables. +This ability for a constant to "cross" types like this will prove useful. + +* Integers + +At last we come to integers. +They have more moving parts—[[http://golang.org/ref/spec#Numeric_types][many sizes, signed or unsigned, and more]]—but they play by the same rules. +For the last time, here is our familiar example, using just `int` this time: + +.play -edit constants/int1.go /START/,/STOP/ + +The same example could be built for any of the integer types, which are: + + int int8 int16 int32 int64 + uint uint8 uint16 uint32 uint64 + uintptr + +(plus the aliases `byte` for `uint8` and `rune` for `int32`). +That's a lot, but the pattern in the way constants work should be familiar enough by now that you can see how things will play out. + +As mentioned above, integers come in a couple of forms and each form has its own default type: `int` for simple constants like `123` or `0xFF` or `-14` +and `rune` for quoted characters like 'a', '世' or '\r'. + +No constant form has as its default type an unsigned integer type. +However, the flexibility of untyped constants means we can initialize unsigned integer variables using simple constants as long as we are clear about the type. +It's analogous to how we can initialize a `float64` using a complex number with zero imaginary part. +Here are several different ways to initialize a `uint`; all are equivalent, but all must mention the type explicitly for the result to be unsigned. + + var u uint = 17 + var u = uint(17) + u := uint(17) + +Similarly to the range issue mentioned in the section on floating-point values, not all integer values can fit in all integer types. +There are two problems that might arise: the value might be too large, or it might be a negative value being assigned to an unsigned integer type. +For instance, `int8` has range -128 through 127, so constants outside of that range can never be assigned to a variable of type `int8`: + +.play -edit constants/int2.go /var/ + +Similarly, `uint8`, also known as `byte`. has range 0 through 255, so a large or negative constant cannot be assigned to a `uint8`: + +.play -edit constants/int3.go /var/ + +This type-checking can catch mistakes like this one: + +.play -edit constants/int4.go /START/,/STOP/ + +If the compiler complains about your use of a constant, it's likely a real bug like this. + +* An exercise: The largest unsigned int + +Here is an informative little exercise. +How do we express a constant representing the largest value that fits in a `uint`? +If we were talking about `uint32` rather than `uint`, we could write + + const MaxUint32 = 1<<32 - 1 + +but we want `uint`, not `uint32`. +The `int` and `uint` types have equal unspecified numbers of bits, either 32 or 64. +Since the number of bits available depends on the architecture, we can't just write down a single value. + +Fans of [[http://en.wikipedia.org/wiki/Two's_complement][two's-complement arithmetic]], +which Go's integers are defined to use, know that the representation of `-1` has all its bits set to 1, +so the bit pattern of `-1` is internally the same as that of the +largest unsigned integer. +We therefore might think we could write + +.play -edit constants/exercise1.go /const/ + +but that is illegal because -1 cannot be represented by an unsigned variable; `-1` is not in the range of unsigned values. +A conversion won't help either, for the same reason: + +.play -edit constants/exercise2.go /const/ + +Even though at run-time a value of -1 can be converted to an unsigned integer, the rules +for constant [[http://golang.org/ref/spec#Conversions][conversions]] forbid this kind of coercion at compile time. +That is to say, this works: + +.play -edit constants/exercise3.go /START/,/STOP/ + +but only because `v` is a variable; if we made `v` a constant, even an untyped constant, we'd be back in forbidden territory: + +.play -edit constants/exercise4.go /START/,/STOP/ + +We return to our previous approach, but instead of `-1` we try `^0`, the bitwise negation of an arbitrary number of zero bits. +But that fails too, for a similar reason: +In the space of numeric values, +`^0` represents an infinite number of ones, so we lose information if we assign that to any fixed-size integer: + +.play -edit constants/exercise5.go /const/ + +How then do we represent the largest unsigned integer as a constant? + +The key is to constrain the operation to the number of bits in a `uint` and avoiding +values, such as negative numbers, that are not representable in a `uint`. +The simplest `uint` value is the typed constant `uint(0)`. +If `uints` have 32 or 64 bits, `uint(0)` has 32 or 64 zero bits accordingly. +If we invert each of those bits, we'll get the correct number of one bits, which is the largest `uint` value. + +Therefore we don't flip the bits of the untyped constant `0`, we flip the bits of the typed constant `uint(0)`. +Here, then, is our constant: + +.play -edit constants/exercise6.go /START/,/STOP/ + +Whatever the number of bits it takes to represent a `uint` in the current execution environment +(on the [[http://blog.golang.org/playground][playground]], it's 32), +this constant correctly represents the largest value a variable of type `uint` can hold. + +If you understand the analysis that got us to this result, you understand all the important points about constants in Go. + +* Numbers + +The concept of untyped constants in Go means that all the numeric constants, whether integer, floating-point, complex, or even character values, +live in a kind of unified space. +It's when we bring them to the computational world of variables, assignments, and operations that the actual types matter. +But as long as we stay in the world of numeric constants, we can mix and match values as we like. +All these constants have numeric value 1: + + 1 + 1.000 + 1e3-99.0*10-9 + '\x01' + '\u0001' + 'b' - 'a' + 1.0+3i-3.0i + +Therefore, although they have different implicit default types, written as untyped constants they can be assigned to a variable of any integer type: + +.play -edit constants/numbers1.go /START/,/STOP/ + +The output from this snippet is: `1 1 1 1 1 (1+0i) 1`. + +You can even do nutty stuff like + +.play -edit constants/numbers2.go /START/,/STOP/ + +which yields 145.5, which is pointless except to prove a point. + +But the real point of these rules is flexibility. +That flexibility means that, despite the fact that in Go it is illegal in the same expression to mix floating-point and integer variables, +or even `int` and `int32` variables, it is fine to write + + sqrt2 := math.Sqrt(2) + +or + + const millisecond = time.Second/1e3 + +or + + bigBufferWithHeader := make([]byte, 512+1e6) + +and have the results mean what you expect. + +Because in Go, numeric constants work as you expect: like numbers. + + diff --git a/content/constants/bool.go b/content/constants/bool.go new file mode 100644 index 0000000..7578d4a --- /dev/null +++ b/content/constants/bool.go @@ -0,0 +1,18 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + // START OMIT + type MyBool bool + const True = true + const TypedTrue bool = true + var mb MyBool + mb = true // OK + mb = True // OK + mb = TypedTrue // Bad + fmt.Println(mb) + // STOP OMIT +} diff --git a/content/constants/complex1.go b/content/constants/complex1.go new file mode 100644 index 0000000..ea45921 --- /dev/null +++ b/content/constants/complex1.go @@ -0,0 +1,18 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + // START OMIT + type MyComplex128 complex128 + const I = (0.0 + 1.0i) + const TypedI complex128 = (0.0 + 1.0i) + var mc MyComplex128 + mc = (0.0 + 1.0i) // OK + mc = I // OK + mc = TypedI // Bad + fmt.Println(mc) + // STOP OMIT +} diff --git a/content/constants/complex2.go b/content/constants/complex2.go new file mode 100644 index 0000000..5dd4f73 --- /dev/null +++ b/content/constants/complex2.go @@ -0,0 +1,13 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + const Two = 2.0 + 0i + // START OMIT + s := Two + fmt.Printf("%T: %v\n", s, s) + // STOP OMIT +} diff --git a/content/constants/complex3.go b/content/constants/complex3.go new file mode 100644 index 0000000..95e9e41 --- /dev/null +++ b/content/constants/complex3.go @@ -0,0 +1,15 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + const Two = 2.0 + 0i + // START OMIT + var f float64 + var g float64 = Two + f = Two + fmt.Println(f, "and", g) + // STOP OMIT +} diff --git a/content/constants/default1.go b/content/constants/default1.go new file mode 100644 index 0000000..914e4b7 --- /dev/null +++ b/content/constants/default1.go @@ -0,0 +1,11 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + // START OMIT + fmt.Printf("Hello, 世界") + // STOP OMIT +} diff --git a/content/constants/default2.go b/content/constants/default2.go new file mode 100644 index 0000000..2183cf0 --- /dev/null +++ b/content/constants/default2.go @@ -0,0 +1,14 @@ +// +build OMIT + +package main + +import "fmt" + +const hello = "Hello, 世界" + +func main() { + // START OMIT + fmt.Printf("%T: %v\n", "Hello, 世界", "Hello, 世界") + fmt.Printf("%T: %v\n", hello, hello) + // STOP OMIT +} diff --git a/content/constants/default3.go b/content/constants/default3.go new file mode 100644 index 0000000..246ae45 --- /dev/null +++ b/content/constants/default3.go @@ -0,0 +1,15 @@ +// +build OMIT + +package main + +import "fmt" + +type MyString string + +const myStringHello MyString = "Hello, 世界" + +func main() { + // START OMIT + fmt.Printf("%T: %v\n", myStringHello, myStringHello) + // STOP OMIT +} diff --git a/content/constants/exercise1.go b/content/constants/exercise1.go new file mode 100644 index 0000000..881d1d0 --- /dev/null +++ b/content/constants/exercise1.go @@ -0,0 +1,9 @@ +// +build OMIT + +package main + +func main() { + // START OMIT + const MaxUint uint = -1 // Error: negative value + // STOP OMIT +} diff --git a/content/constants/exercise2.go b/content/constants/exercise2.go new file mode 100644 index 0000000..db7d8c1 --- /dev/null +++ b/content/constants/exercise2.go @@ -0,0 +1,9 @@ +// +build OMIT + +package main + +func main() { + // START OMIT + const MaxUint uint = uint(-1) // Error: negative value + // STOP OMIT +} diff --git a/content/constants/exercise3.go b/content/constants/exercise3.go new file mode 100644 index 0000000..dbe7595 --- /dev/null +++ b/content/constants/exercise3.go @@ -0,0 +1,12 @@ +// +build OMIT + +package main + +func main() { + // START OMIT + var u uint + var v = -1 + u = uint(v) + // STOP OMIT + _ = u +} diff --git a/content/constants/exercise4.go b/content/constants/exercise4.go new file mode 100644 index 0000000..3acc664 --- /dev/null +++ b/content/constants/exercise4.go @@ -0,0 +1,12 @@ +// +build OMIT + +package main + +func main() { + // START OMIT + var u uint + const v = -1 + u = uint(v) // Error: negative value + // STOP OMIT + _ = u +} diff --git a/content/constants/exercise5.go b/content/constants/exercise5.go new file mode 100644 index 0000000..2fca330 --- /dev/null +++ b/content/constants/exercise5.go @@ -0,0 +1,9 @@ +// +build OMIT + +package main + +func main() { + // START OMIT + const MaxUint uint = ^0 // Error: overflow + // STOP OMIT +} diff --git a/content/constants/exercise6.go b/content/constants/exercise6.go new file mode 100644 index 0000000..ce6478c --- /dev/null +++ b/content/constants/exercise6.go @@ -0,0 +1,12 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + // START OMIT + const MaxUint = ^uint(0) + fmt.Printf("%x\n", MaxUint) + // STOP OMIT +} diff --git a/content/constants/float1.go b/content/constants/float1.go new file mode 100644 index 0000000..96b3bb9 --- /dev/null +++ b/content/constants/float1.go @@ -0,0 +1,18 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + // START OMIT + type MyFloat64 float64 + const Zero = 0.0 + const TypedZero float64 = 0.0 + var mf MyFloat64 + mf = 0.0 // OK + mf = Zero // OK + mf = TypedZero // Bad + fmt.Println(mf) + // STOP OMIT +} diff --git a/content/constants/float2.go b/content/constants/float2.go new file mode 100644 index 0000000..f43feb6 --- /dev/null +++ b/content/constants/float2.go @@ -0,0 +1,17 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + const Zero = 0.0 + const TypedZero float64 = 0.0 + // START OMIT + var f32 float32 + f32 = 0.0 + f32 = Zero // OK: Zero is untyped + f32 = TypedZero // Bad: TypedZero is float64 not float32. + fmt.Println(f32) + // STOP OMIT +} diff --git a/content/constants/float3.go b/content/constants/float3.go new file mode 100644 index 0000000..d862acc --- /dev/null +++ b/content/constants/float3.go @@ -0,0 +1,12 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + const Huge = 1e1000 + // START OMIT + fmt.Println(Huge) + // STOP OMIT +} diff --git a/content/constants/float4.go b/content/constants/float4.go new file mode 100644 index 0000000..206d215 --- /dev/null +++ b/content/constants/float4.go @@ -0,0 +1,12 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + const Huge = 1e1000 + // START OMIT + fmt.Println(Huge / 1e999) + // STOP OMIT +} diff --git a/content/constants/float5.go b/content/constants/float5.go new file mode 100644 index 0000000..2d62872 --- /dev/null +++ b/content/constants/float5.go @@ -0,0 +1,15 @@ +// +build OMIT + +package main + +import ( + "fmt" + "math" +) + +func main() { + // START OMIT + pi := math.Pi + fmt.Println(pi) + // STOP OMIT +} diff --git a/content/constants/int1.go b/content/constants/int1.go new file mode 100644 index 0000000..913ad78 --- /dev/null +++ b/content/constants/int1.go @@ -0,0 +1,18 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + // START OMIT + type MyInt int + const Three = 3 + const TypedThree int = 3 + var mi MyInt + mi = 3 // OK + mi = Three // OK + mi = TypedThree // Bad + fmt.Println(mi) + // STOP OMIT +} diff --git a/content/constants/int2.go b/content/constants/int2.go new file mode 100644 index 0000000..0e974ef --- /dev/null +++ b/content/constants/int2.go @@ -0,0 +1,10 @@ +// +build OMIT + +package main + +func main() { + // START OMIT + var i8 int8 = 128 // Error: too large. + // STOP OMIT + _ = i8 +} diff --git a/content/constants/int3.go b/content/constants/int3.go new file mode 100644 index 0000000..c2cec6e --- /dev/null +++ b/content/constants/int3.go @@ -0,0 +1,10 @@ +// +build OMIT + +package main + +func main() { + // START OMIT + var u8 uint8 = -1 // Error: negative value. + // STOP OMIT + _ = u8 +} diff --git a/content/constants/int4.go b/content/constants/int4.go new file mode 100644 index 0000000..caff695 --- /dev/null +++ b/content/constants/int4.go @@ -0,0 +1,11 @@ +// +build OMIT + +package main + +func main() { + // START OMIT + type Char byte + var c Char = '世' // Error: '世' has value 0x4e16, too large. + // STOP OMIT + _ = c +} diff --git a/content/constants/numbers1.go b/content/constants/numbers1.go new file mode 100644 index 0000000..ea35a51 --- /dev/null +++ b/content/constants/numbers1.go @@ -0,0 +1,19 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + // START OMIT + var f float32 = 1 + var i int = 1.000 + var u uint32 = 1e3 - 99.0*10.0 - 9 + var c float64 = '\x01' + var p uintptr = '\u0001' + var r complex64 = 'b' - 'a' + var b byte = 1.0 + 3i - 3.0i + + fmt.Println(f, i, u, c, p, r, b) + // STOP OMIT +} diff --git a/content/constants/numbers2.go b/content/constants/numbers2.go new file mode 100644 index 0000000..33b7de0 --- /dev/null +++ b/content/constants/numbers2.go @@ -0,0 +1,12 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + // START OMIT + var f = 'a' * 1.5 + fmt.Println(f) + // STOP OMIT +} diff --git a/content/constants/string1.go b/content/constants/string1.go new file mode 100644 index 0000000..3b83851 --- /dev/null +++ b/content/constants/string1.go @@ -0,0 +1,15 @@ +// +build OMIT + +package main + +import "fmt" + +const typedHello string = "Hello, 世界" + +func main() { + // START OMIT + var s string + s = typedHello + fmt.Println(s) + // STOP OMIT +} diff --git a/content/constants/string2.go b/content/constants/string2.go new file mode 100644 index 0000000..362b484 --- /dev/null +++ b/content/constants/string2.go @@ -0,0 +1,16 @@ +// +build OMIT + +package main + +import "fmt" + +const typedHello string = "Hello, 世界" + +func main() { + // START OMIT + type MyString string + var m MyString + m = typedHello // Type error + fmt.Println(m) + // STOP OMIT +} diff --git a/content/constants/string3.go b/content/constants/string3.go new file mode 100644 index 0000000..72de35f --- /dev/null +++ b/content/constants/string3.go @@ -0,0 +1,17 @@ +// +build OMIT + +package main + +import "fmt" + +const typedHello string = "Hello, 世界" + +func main() { + type MyString string + var m MyString + // START OMIT + const myStringHello MyString = "Hello, 世界" + m = myStringHello // OK + fmt.Println(m) + // STOP OMIT +} diff --git a/content/constants/string4.go b/content/constants/string4.go new file mode 100644 index 0000000..4c35f29 --- /dev/null +++ b/content/constants/string4.go @@ -0,0 +1,16 @@ +// +build OMIT + +package main + +import "fmt" + +const typedHello string = "Hello, 世界" + +func main() { + type MyString string + var m MyString + // START OMIT + m = MyString(typedHello) + fmt.Println(m) + // STOP OMIT +} diff --git a/content/constants/syntax.go b/content/constants/syntax.go new file mode 100644 index 0000000..16e7e64 --- /dev/null +++ b/content/constants/syntax.go @@ -0,0 +1,14 @@ +// +build OMIT + +package main + +import "fmt" + +func main() { + // START OMIT + fmt.Printf("%T %v\n", 0, 0) + fmt.Printf("%T %v\n", 0.0, 0.0) + fmt.Printf("%T %v\n", 'x', 'x') + fmt.Printf("%T %v\n", 0i, 0i) + // STOP OMIT +} |