extern crate uuid;

// we create a namespace to enforce that I can't create an authenticated user
// by directly calling it (session is not public so you can't set it)
mod users {
    use uuid::Uuid;

    pub struct UnauthenticatedUser {
        pub name: String,
    }

    pub struct AuthenticatedUser {
        pub name: String,
        _session: String,
    }

    impl UnauthenticatedUser {
        pub fn authenticate(self, _password: String) -> AuthenticatedUser {
            // check auth, if successful create an authenticated user with session
            AuthenticatedUser {
                name: self.name,
                _session: format!("{}", Uuid::new_v4())
            }
        }
    }

    impl AuthenticatedUser {
        pub fn do_stuff(&self) {
            //does something that only authenticated users can do
        }

        pub fn logout(self) -> UnauthenticatedUser {
            UnauthenticatedUser {
                name: self.name
            }
        }
    }
}

use users::*;

fn main() {
    // create a user
    let user = UnauthenticatedUser {
        name: String::from("d0nut")
    };

    // sign in
    let authenticated_user = user.authenticate(String::from("hunter2"));

    // do some cool authenticated user stuff
    authenticated_user.do_stuff();

    // sign out; `authenticated_user` shouldn't be accessible anymore
    authenticated_user.logout();

    // this line can't compile because we logged the user out ;)
    authenticated_user.do_stuff();
}