uint

Parse is less explicit than unwrap because the following C# code is legal: uint foo = uint.

Instead of (uint, int) we could have (int, sint) or (uint, sint).

If a = uint64(1) and x = uint(64), then a << b always gives 0 in Go.

Using a uint only serves to make it harder to test when your system is in an invalid state.

The next version (0.9.0) has support for tags and efficiently encodes the measurement name + tagset as a single 4 byte uint.

That's not really an optimal way to check divisibility though, if you want to be quick try: fizz = (uint)i*2863311531 <= (uint)i; buzz = (uint)i*3435973837 <= (uint)i; Should work for fine for i<=1000.

Parse and let the exception bubble up, you'd call uint.

Go does allow fixed size arrays in structs, and they're inline in the struct, so `struct { foo [8]uint }` is 32 bytes, whereas `struct { foo []uint }` is 12 bytes and `struct { foo string }` is 8.

There has been a huuuuuge amount of discussion about int/uint and naming, expect some clarification sometime soonish, as any changes (if any) would have to be made soon.

For example 'ID' came out as float64, and it looks like the tool will never generate int fields, even though a ton of fields are actually 'int' or 'uint' in my experience.

Just for legacy sake, it probably wouldn't make sense to switch the meaning of 'int' in Rust to 'uint', whilst creating a new type 'sint' to emulate the old meaning of 'int'.

Seeing how the Rust community seems to have converged on using `uint` as the default type for array indexing and so on; wouldn't it make sense to reflect that in the complexity of the name of the types?

Could it be that the lack of support for "low level" stuff like uint is holding Java back on embedded systems?

The "can not hold negative values" argument is also weak because a uint does not prevent generating negative values - it only prevents you from knowing that you've generated negative values.

Both Rust and C# provide throwing/failing interfaces for parsing, it's just that Rust's is written: let foo: u32 = "3".parse().unwrap(); and C#'s is written: var foo = uint.

You invariably must acknowledge the possibility of failure, and if you're okay with terminating your thread in the event of an error you can do this via an unwrap: let foo: u32 = "3".parse().unwrap(); // just fine Rust's parse is even more explicit than C#'s TryParse, because even with TryParse it's possible to forget to check the return value: uint foo; uint.