## Object (dis)orientation

###### How to survive a "post-OO" world

Class/Inheritance has challenges
Combining Data + Code

    		class MyBase {
    			protected:
    				int useless;
    			public:
    				virtual void makeSound() = 0;

    				virtual int get_thing() {
    					return -1;
    				};
    		};

You have to know if this is an "interface", abstract class, or regular class.

(it's an abstract class, since `makeSound` is pure virtual)

A class can be one of many things

- Interface - abstract class with no members, and purely virtual
- Abstract Class - class with some pure virtual methods
- "Regular" Class - class that is standalone and is fully implemented

These concepts all exist under the `class` keyword
In Rust, you trade Inheritance for Traits and Types.

Traits are Interfaces

    	pub trait Mammal {
    		fn get_temp(&self) -> i32;
    	}

... that are explicitly implemented

    		pub struct Cat {
    			age: i32,
    			outdoor: bool,
    		}
    		impl Mammal for Cat {
    			fn get_temp(&self) -> i32 {
    				if self.outdoor {
    					65
    				} else {
    					72
    				}
    			}
    		}

And can be used statically or dynamically!

    		fn static_mammal<T: Mammal>(m: T) {
    			// the type of T must be known at compile time.
    		}
    		fn dyn_mammal(m: &dyn Mammal) {
    			// This uses a vtable to dispatch at runtime.
    		}