You can use == to compare with a zero value composite literal because all fields in Session are comparable: if (Session{}) == session { fmt.Println(“is zero value”) } playground example Because of a parsing ambiguity, parentheses are required around the composite literal in the if condition. The use of == above applies to structs where … Read more
Lifetime ‘a in fn foo(&’a self, …) … is defined for impl<‘a>, that is it is the same for all foo calls. Lifetime ‘a in fn get_mut<‘a>(&’a mut self) … is defined for the function. Different calls of get_mut can have different values for ‘a. Your code impl<‘a> Foo<‘a> { fn foo(&’a self, path: &str) … Read more
is there a way to do it without extracting their “inner” values every time with pattern matching, and without implementing the Add, Sub, … traits and overloading operators? No, the only way is to implement the traits manually. Rust doesn’t have an equivalent to the Haskell’s GHC extension GeneralizedNewtypeDeriving which allows deriving on wrapper types … Read more
The assignability rules are forgiving for anonymous types which leads to another possibility where you can retain the original definition of A while allowing short composite literals of that type to be written. If you really insist on an anonymous type for the B field, I would probably write something like: package main import “fmt” … Read more
To give a reference to OneOfOne’s answer, see the Conversions section of the spec. It states that A non-constant value x can be converted to type T in any of these cases: x is assignable to T. x‘s type and T have identical underlying types. x‘s type and T are unnamed pointer types and their … Read more
This is something not possible. To better understand why, see this slightly modified version of your example: type B struct{} func (b *B) Validate() { fmt.Printf(“b:%p\n”, b) } type A struct { *B } func main() { b := B{} a1 := A{&b} a2 := A{&b} a1.Validate() a2.Validate() a1.B.Validate() a2.B.Validate() b.Validate() } Output as expected, … Read more
There are a few problems. The first is that there’s nothing to require that an Animal also implements Clone. You could fix this by changing the trait definition: trait Animal: Clone { /* … */ } This would cause Animal to no longer be object safe, meaning that Box<dyn Animal> will become invalid, so that’s … Read more