armanriazi•rust•syntax•names
'turbofish': ::<>() , ::. Combined with the (angular brackets=Bound) for generics
'fully qualified syntax' : <Type as Trait>::function(receiver_if_method, next_arg, ...);
'path': ::
'closure': <> , || {} , Closures are represented by traits, so they cannot be a return type, let consume_and_return_x = move || x;
'&': borrow
'*': dereference
'!': that’s known in type theory lingo as the empty type because it has no values. We prefer to call it the never type.Functions that return never are called diverging functions.
'$str': literal string
''a': lifetime a, lifetime=timetolive=subset of their scope, &'a mut i32 // a mutable reference with an explicit lifetime
'implicit': encapsulation (like method, copy)
'bound' : 'where Self: Sized'
'DSTs': unsized types
'?Sized': T may or may not be Sized-Trait syntax with this meaning is only available for Sized, this notation overrides the default that generic types must have a known size at compile time. not any other traits.
'The associated type = placeholder type' : is named Item'pub trait Iterator {type Item;}'another example is ' HasAssocType<Ty = T>'
'default type parameters = right hand side' : Example
```trait Add<Rhs=Self> { type Output; fn add(self, rhs: Rhs) -> Self::Output;}```
```another example:
'thin wrapper around the type' : part of Vec<String> is noticed. struct Wrapper(Vec<String>);
'newtype pattern = wrapper type = NewPattern ' : thin wrapping of an existing type in another struct
impl Add<Meters> for Millimeters {type Output = Millimeters;fn add(self, other: Meters) -> Millimeters {}}
// we specify impl Add<Meters> to set the value of the Rhs type parameter instead of using the default of Self
```
'receiver' : for exampele of type of Self (i.e. self) implies this
'impl<T, U> GenericTrait<U> for u32 where U: HasAssocType<Ty = T> {}'
/*The syntax for specifying a default type for a generic type is <PlaceholderType=ConcreteType> when declaring the generic type.*/
/* 'T' ""constrains"" by being in an ""associated type(Ty = T)"" in a bound for type `U` which is itself a ""generic parameter(GenericTrait<U>)"" constraining the trait.*/
---
Rust has a feature called automatic referencing and dereferencing.
Calling methods is one of the few places in Rust that has this behavior.
p1.distance(&p2);
(&p1).distance(&p2);
----
In Rust, global variables are called static variables
----
https://doc.rust-lang.org/nightly/reference/glossary.html
https://doc.rust-lang.org/reference/notation.html