Turns out, this is a misunderstanding that I had about how Go dealt with types, which can be resolved by reading the relevant part of the spec: http://golang.org/ref/spec#Type_identity The relevant distinction that I was unaware of was that of named and unnamed types. Named types are types with a name, such as int, int64, float, … Read more
You also can do type switches: switch v := myInterface.(type) { case int: // v is an int here, so e.g. v + 1 is possible. fmt.Printf(“Integer: %v”, v) case float64: // v is a float64 here, so e.g. v + 1.0 is possible. fmt.Printf(“Float64: %v”, v) case string: // v is a string here, … Read more
& in a type position means intersection type. More from typescript docs on Intersection Types: https://www.typescriptlang.org/docs/handbook/2/objects.html#intersection-types Citation from the docs linked above: Intersection types are closely related to union types, but they are used very differently. An intersection type combines multiple types into one. This allows you to add together existing types to get a … Read more
This is now touched on in the second edition of The Rust Programming Language. However, let’s dive in a bit in addition. Let us start with a simpler example. When is it appropriate to use a trait method? There are multiple ways to provide late binding: trait MyTrait { fn hello_word(&self) -> String; } Or: … Read more
2mantissa bits + 1 + 1 The +1 in the exponent (mantissa bits + 1) is because, if the mantissa contains abcdef… the number it represents is actually 1.abcdef… × 2^e, providing an extra implicit bit of precision. Therefore, the first integer that cannot be accurately represented and will be rounded is: For 32-bit floats, … Read more
I just found something in the TypeScript language specification, it’s fairly easy. I was pretty close. the syntax is the following: public myCallback: (name: type) => returntype; In my example, it would be class CallbackTest { public myCallback: () => void; public doWork(): void { //doing some work… this.myCallback(); //calling callback } } As a … Read more
The biggest/largest integer that can be stored in a double without losing precision is the same as the largest possible value of a double. That is, DBL_MAX or approximately 1.8 × 10308 (if your double is an IEEE 754 64-bit double). It’s an integer. It’s represented exactly. What more do you want? Go on, ask me what … Read more
You can use the std::any::type_name function. This doesn’t need a nightly compiler or an external crate, and the results are quite correct: fn print_type_of<T>(_: &T) { println!(“{}”, std::any::type_name::<T>()) } fn main() { let s = “Hello”; let i = 42; print_type_of(&s); // &str print_type_of(&i); // i32 print_type_of(&main); // playground::main print_type_of(&print_type_of::<i32>); // playground::print_type_of<i32> print_type_of(&{ || “Hi!” … Read more