pub struct JsValue;

impl AsRef<JsValue> for JsValue {
    fn as_ref(&self) -> &JsValue {
        self
    }
}

impl AsMut<JsValue> for JsValue {
    fn as_mut(&mut self) -> &mut JsValue {
        self
    }
}

pub trait InstanceOf: Into<JsValue> {
    fn instanceof(val: &JsValue) -> bool;

    fn unchecked_from_js(val: JsValue) -> Self;
    fn unchecked_from_js_ref(val: &JsValue) -> &Self;
    fn unchecked_from_js_mut(val: &mut JsValue) -> &mut Self;
}

pub trait Cast
where
    Self: AsRef<JsValue> + AsMut<JsValue> + Into<JsValue>,
{
    // Unchecked conversions.

    fn unchecked_into<T>(self) -> T
    where
        T: InstanceOf,
    {
        T::unchecked_from_js(self.into())
    }
    fn unchecked_ref<T>(&self) -> &T
    where
        T: InstanceOf,
    {
        T::unchecked_from_js_ref(self.as_ref())
    }
    fn unchecked_mut<T>(&mut self) -> &mut T
    where
        T: InstanceOf,
    {
        T::unchecked_from_js_mut(self.as_mut())
    }

    // Dynamic instanceof check.

    fn is_instance_of<T>(&self) -> bool
    where
        T: InstanceOf,
    {
        T::instanceof(self.as_ref())
    }

    // Dynamically-checked conversions.

    fn try_into<T>(self) -> Result<T, Self>
    where
        T: InstanceOf,
    {
        if self.is_instance_of::<T>() {
            Ok(self.unchecked_into())
        } else {
            Err(self)
        }
    }

    fn try_ref<T>(&self) -> Option<&T>
    where
        T: InstanceOf,
    {
        if self.is_instance_of::<T>() {
            Some(self.unchecked_ref())
        } else {
            None
        }
    }

    fn try_mut<T>(&mut self) -> Option<&mut T>
    where
        T: InstanceOf,
    {
        if self.is_instance_of::<T>() {
            Some(self.unchecked_mut())
        } else {
            None
        }
    }
}

impl<U> Cast for U where U: AsRef<JsValue> + AsMut<JsValue> + Into<JsValue> {}

struct Object;

impl InstanceOf for Object {
    fn instanceof(_val: &JsValue) -> bool {
        unimplemented!()
    }
    fn unchecked_from_js(_val: JsValue) -> Self {
        unimplemented!()
    }
    fn unchecked_from_js_ref(_val: &JsValue) -> &Self {
        unimplemented!()
    }
    fn unchecked_from_js_mut(_val: &mut JsValue) -> &mut Self {
        unimplemented!()
    }
}

impl From<Object> for JsValue {
    fn from(_o: Object) -> JsValue {
        unimplemented!()
    }
}

impl AsRef<JsValue> for Object {
    fn as_ref(&self) -> &JsValue {
        unimplemented!()
    }
}

impl AsMut<JsValue> for Object {
    fn as_mut(&mut self) -> &mut JsValue {
        unimplemented!()
    }
}

fn main() {
    let v = JsValue;
    v.is_instance_of::<Object>();
}