fn unwrap<T>(option: Option<T>) -> T{
    let unwrapped = match option{
        Some(val) => val,
        None => panic!("This cannot be None!")
    };
    return unwrapped;
}
fn main() {
    let unwrapped = unwrap(Some(0));
}

#![feature(never_type)]
use std::convert::TryInto;
#[derive(Debug)]
enum ConnectionError{
    BrokenPipe,
    BadId,
    Other
}
struct Client;
struct Request;
struct Response;
impl Request{
    pub fn build_response(&self) -> Response{
        Response
    }
}
fn get_request(id: i32) -> Result<(Client, Request), ConnectionError>{
    match id % 2 == 0{
        true => {
            Ok((Client, Request))
        },
        false => {
            Err(ConnectionError::BadId)
        }
    }
}
fn init_server() -> Result<!, ConnectionError>{
    loop {
        let (client, request) = get_request(5i32)?;
        let resp = request.build_response();
    };
}
fn main() {
    let x: ! = init_server().unwrap();
}

fn init_server() -> Result<(), ConnectionError>{
    loop {
        let (client, request) = get_request(5i32)?;
        let resp = request.build_response();
    };
}
fn main() {
    let x = init_server().unwrap();
}

fn main() {
    match init_server(){
        Ok(v) => { println!("unreachable? {:?}", v); },
        Err(_) => {}
    };
}

use std::any::type_name;
fn type_of<T>(x: T) -> &'static str {
    type_name::<T>()
}
fn callback() -> impl Fn(f32) -> f32{
    |a| {
      a*2.
    }
}
fn main() {
    let x = callback();
    println!("{}", type_of(x));
}

fn main() {
    let x: Box<dyn Fn(f32) -> f32> = Box::new(callback());
    println!("{}", type_of(x));
}

use tokio; // 1.0.2
use tokio::task::JoinError;
use futures::prelude::*; // 0.3.12
async fn job1(){}
async fn job2(){
  for i in 0..5{}
}
async fn job() -> Vec<impl Future<Output = Result<(), JoinError>>>{
    vec![
    tokio::spawn(async move{
        job1().await;
    }),
    tokio::spawn(async move{
        job2().await;
    })]
}
#[tokio::main]
async fn main() {
    let mut v = job();
}

let v = vec![
        Box::new(async{}),
        Box::new(async{
            let cb = |x| x*2.;
            let val = cb(1f32);
        })
    ];