[−][src]Trait screeps::traits::TryFrom

pub trait TryFrom<T> {
    type Error;
    fn try_from(T) -> Result<Self, Self::Error>;
}

Attempt to construct Self via a conversion.

This definition is only temporary until Rust's TryFrom is stabilized.

Associated Types

`type Error`

The type returned in the event of a conversion error.

Loading content...

Required methods

`fn try_from(T) -> Result<Self, Self::Error>`

Performs the conversion.

Loading content...

Implementations on Foreign Types

`impl<'_r> TryFrom<&'_r Reference> for EventTarget`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<EventTarget, <EventTarget as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<TouchLeave> for Reference`[src]

`type Error = Void`

`fn try_from( value: TouchLeave ) -> Result<Reference, <Reference as TryFrom<TouchLeave>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragStartEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragStartEvent, <DragStartEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for GotPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<MutationObserver> for Reference`[src]

`type Error = Void`

`fn try_from( value: MutationObserver ) -> Result<Reference, <Reference as TryFrom<MutationObserver>>::Error>`[src]

`impl TryFrom<Value> for Option<i16>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<i16>, <Option<i16> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for ImageElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ImageElement, <ImageElement as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<SecurityError> for Reference`[src]

`type Error = Void`

`fn try_from( value: SecurityError ) -> Result<Reference, <Reference as TryFrom<SecurityError>>::Error>`[src]

`impl TryFrom<Value> for InputElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<InputElement, <InputElement as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for GamepadButton`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<GamepadButton, <GamepadButton as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ShadowRoot`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ShadowRoot, <ShadowRoot as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<KeyUpEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: KeyUpEvent ) -> Result<Reference, <Reference as TryFrom<KeyUpEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for XmlHttpRequest`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<XmlHttpRequest, <XmlHttpRequest as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SlotChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SlotChangeEvent, <SlotChangeEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragRelatedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragRelatedEvent, <DragRelatedEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Node> for TemplateElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<TemplateElement, <TemplateElement as TryFrom<Node>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Error`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Error, <Error as TryFrom<&'_r Value>>::Error>`[src]

`impl<T> TryFrom<TypedArray<T>> for Reference where T: ArrayKind,` [src]

`type Error = Void`

`fn try_from( value: TypedArray<T> ) -> Result<Reference, <Reference as TryFrom<TypedArray<T>>>::Error>`[src]

`impl TryFrom<MouseEnterEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseEnterEvent ) -> Result<Reference, <Reference as TryFrom<MouseEnterEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for FormData`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<FormData, <FormData as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for GamepadButton`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<GamepadButton, <GamepadButton as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<UiEvent> for PointerDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<HtmlElement> for CanvasElement`[src]

`type Error = ConversionError`

`fn try_from( value: HtmlElement ) -> Result<CanvasElement, <CanvasElement as TryFrom<HtmlElement>>::Error>`[src]

`impl TryFrom<File> for Reference`[src]

`type Error = Void`

`fn try_from( value: File ) -> Result<Reference, <Reference as TryFrom<File>>::Error>`[src]

`impl TryFrom<Value> for DragEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragEvent, <DragEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for PointerMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerMoveEvent, <PointerMoveEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for GamepadConnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<GamepadConnectedEvent, <GamepadConnectedEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for MouseMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<MouseMoveEvent, <MouseMoveEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<TouchEvent> for TouchCancel`[src]

`type Error = ConversionError`

`fn try_from( value: TouchEvent ) -> Result<TouchCancel, <TouchCancel as TryFrom<TouchEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Blob`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Blob, <Blob as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for ImageElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ImageElement, <ImageElement as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TouchCancel`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TouchCancel, <TouchCancel as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for PointerCancelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerCancelEvent, <PointerCancelEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for TouchMove`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<TouchMove, <TouchMove as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TouchMove`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TouchMove, <TouchMove as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerUpEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerUpEvent, <PointerUpEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for TokenList`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TokenList, <TokenList as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerLockErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerLockErrorEvent, <PointerLockErrorEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Number> for u64`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<u64, <u64 as TryFrom<Number>>::Error>`[src]

`impl TryFrom<Reference> for Gamepad`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Gamepad, <Gamepad as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for MouseLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<MouseLeaveEvent, <MouseLeaveEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<u32> for Number`[src]

`type Error = Void`

`fn try_from(value: u32) -> Result<Number, <Number as TryFrom<u32>>::Error>`[src]

`impl TryFrom<Value> for DragDropEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragDropEvent, <DragDropEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for DomException`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DomException, <DomException as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SocketMessageEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SocketMessageEvent, <SocketMessageEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'a> TryFrom<&'a bool> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a bool ) -> Result<Value, <Value as TryFrom<&'a bool>>::Error>`[src]

`impl TryFrom<DragLeaveEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DragLeaveEvent ) -> Result<Reference, <Reference as TryFrom<DragLeaveEvent>>::Error>`[src]

`impl TryFrom<Reference> for MouseOverEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<MouseOverEvent, <MouseOverEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<TouchStart> for Reference`[src]

`type Error = Void`

`fn try_from( value: TouchStart ) -> Result<Reference, <Reference as TryFrom<TouchStart>>::Error>`[src]

`impl TryFrom<EventTarget> for Reference`[src]

`type Error = Void`

`fn try_from( value: EventTarget ) -> Result<Reference, <Reference as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<i64> for Number`[src]

`type Error = ConversionError`

`fn try_from(value: i64) -> Result<Number, <Number as TryFrom<i64>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for History`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<History, <History as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for GetImageDataError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<GetImageDataError, <GetImageDataError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for FocusEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<FocusEvent, <FocusEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for ProgressErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ProgressErrorEvent, <ProgressErrorEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for PointerEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<PointerEnterEvent, <PointerEnterEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Reference> for SelectionChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SelectionChangeEvent, <SelectionChangeEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for TemplateElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TemplateElement, <TemplateElement as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for MouseMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<MouseMoveEvent, <MouseMoveEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for DataTransferItem`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DataTransferItem, <DataTransferItem as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Error> for InvalidStateError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<InvalidStateError, <InvalidStateError as TryFrom<Error>>::Error>`[src]

`impl TryFrom<Reference> for SubmitEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SubmitEvent, <SubmitEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for GamepadDisconnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<GamepadDisconnectedEvent, <GamepadDisconnectedEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Element> for OptionElement`[src]

`type Error = ConversionError`

`fn try_from( value: Element ) -> Result<OptionElement, <OptionElement as TryFrom<Element>>::Error>`[src]

`impl TryFrom<Node> for TextAreaElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<TextAreaElement, <TextAreaElement as TryFrom<Node>>::Error>`[src]

`impl TryFrom<SelectionChangeEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: SelectionChangeEvent ) -> Result<Reference, <Reference as TryFrom<SelectionChangeEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for NodeList`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<NodeList, <NodeList as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ResourceAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ResourceAbortEvent, <ResourceAbortEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Storage> for Reference`[src]

`type Error = Void`

`fn try_from( value: Storage ) -> Result<Reference, <Reference as TryFrom<Storage>>::Error>`[src]

`impl TryFrom<char> for Value`[src]

`type Error = Void`

`fn try_from(source: char) -> Result<Value, <Value as TryFrom<char>>::Error>`[src]

`impl TryFrom<Error> for IndexSizeError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<IndexSizeError, <IndexSizeError as TryFrom<Error>>::Error>`[src]

`impl TryFrom<Number> for f64`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<f64, <f64 as TryFrom<Number>>::Error>`[src]

`impl TryFrom<UiEvent> for MouseMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<MouseMoveEvent, <MouseMoveEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Value> for f64`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<f64, <f64 as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DragExitEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DragExitEvent, <DragExitEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for PointerOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerOutEvent, <PointerOutEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SyntaxError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SyntaxError, <SyntaxError as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for File`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<File, <File as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for CanvasElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<CanvasElement, <CanvasElement as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for ResourceLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ResourceLoadEvent, <ResourceLoadEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<TouchEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: TouchEvent ) -> Result<Reference, <Reference as TryFrom<TouchEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DocumentFragment`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DocumentFragment, <DocumentFragment as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<TouchEvent> for TouchEnd`[src]

`type Error = ConversionError`

`fn try_from( value: TouchEvent ) -> Result<TouchEnd, <TouchEnd as TryFrom<TouchEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerCancelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerCancelEvent, <PointerCancelEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<FocusRelatedEvent> for FocusEvent`[src]

`type Error = ConversionError`

`fn try_from( value: FocusRelatedEvent ) -> Result<FocusEvent, <FocusEvent as TryFrom<FocusRelatedEvent>>::Error>`[src]

`impl TryFrom<Reference> for FileList`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<FileList, <FileList as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<HtmlElement> for SlotElement`[src]

`type Error = ConversionError`

`fn try_from( value: HtmlElement ) -> Result<SlotElement, <SlotElement as TryFrom<HtmlElement>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for CanvasGradient`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<CanvasGradient, <CanvasGradient as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Document`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Document, <Document as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for NodeList`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<NodeList, <NodeList as TryFrom<Value>>::Error>`[src]

`impl TryFrom<DomException> for Reference`[src]

`type Error = Void`

`fn try_from( value: DomException ) -> Result<Reference, <Reference as TryFrom<DomException>>::Error>`[src]

`impl TryFrom<Reference> for CanvasGradient`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<CanvasGradient, <CanvasGradient as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<MouseLeaveEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseLeaveEvent ) -> Result<Reference, <Reference as TryFrom<MouseLeaveEvent>>::Error>`[src]

`impl<T> TryFrom<Serde<T>> for Value where T: Serialize,` [src]

`type Error = ConversionError`

`fn try_from( value: Serde<T> ) -> Result<Value, <Value as TryFrom<Serde<T>>>::Error>`[src]

`impl TryFrom<MouseEvent> for PointerOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<PointerOverEvent, <PointerOverEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<GotPointerCaptureEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: GotPointerCaptureEvent ) -> Result<Reference, <Reference as TryFrom<GotPointerCaptureEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SocketErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SocketErrorEvent, <SocketErrorEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Event> for PopStateEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PopStateEvent, <PopStateEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Gamepad> for Reference`[src]

`type Error = Void`

`fn try_from( value: Gamepad ) -> Result<Reference, <Reference as TryFrom<Gamepad>>::Error>`[src]

`impl TryFrom<ImageElement> for Reference`[src]

`type Error = Void`

`fn try_from( value: ImageElement ) -> Result<Reference, <Reference as TryFrom<ImageElement>>::Error>`[src]

`impl TryFrom<Reference> for PointerOverEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerOverEvent, <PointerOverEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragLeaveEvent, <DragLeaveEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<ProgressLoadEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ProgressLoadEvent ) -> Result<Reference, <Reference as TryFrom<ProgressLoadEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for TouchLeave`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<TouchLeave, <TouchLeave as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ImageElement`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ImageElement, <ImageElement as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for InvalidAccessError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<InvalidAccessError, <InvalidAccessError as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for PointerMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerMoveEvent, <PointerMoveEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Error> for SecurityError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<SecurityError, <SecurityError as TryFrom<Error>>::Error>`[src]

`impl TryFrom<Value> for PopStateEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PopStateEvent, <PopStateEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ResourceErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ResourceErrorEvent, <ResourceErrorEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for CanvasPattern`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<CanvasPattern, <CanvasPattern as TryFrom<Reference>>::Error>`[src]

`impl<K, V> TryFrom<HashMap<K, V, RandomState>> for Object where K: AsRef<str> + Eq + Hash, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: HashMap<K, V, RandomState> ) -> Result<Object, <Object as TryFrom<HashMap<K, V, RandomState>>>::Error>`[src]

`impl TryFrom<Reference> for TouchStart`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TouchStart, <TouchStart as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for TouchLeave`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TouchLeave, <TouchLeave as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DoubleClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DoubleClickEvent, <DoubleClickEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Rect`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Rect, <Rect as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for ResourceErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ResourceErrorEvent, <ResourceErrorEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<PointerEnterEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerEnterEvent ) -> Result<Reference, <Reference as TryFrom<PointerEnterEvent>>::Error>`[src]

`impl TryFrom<FileReader> for Reference`[src]

`type Error = Void`

`fn try_from( value: FileReader ) -> Result<Reference, <Reference as TryFrom<FileReader>>::Error>`[src]

`impl TryFrom<PopStateEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PopStateEvent ) -> Result<Reference, <Reference as TryFrom<PopStateEvent>>::Error>`[src]

`impl TryFrom<Value> for DocumentFragment`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DocumentFragment, <DocumentFragment as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for u64`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<u64, <u64 as TryFrom<Value>>::Error>`[src]

`impl TryFrom<DragRelatedEvent> for DragEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: DragRelatedEvent ) -> Result<DragEnterEvent, <DragEnterEvent as TryFrom<DragRelatedEvent>>::Error>`[src]

`impl TryFrom<Value> for Rect`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Rect, <Rect as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for Value`[src]

`type Error = Void`

`fn try_from(source: Value) -> Result<Value, <Value as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for Option<Symbol>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<Symbol>, <Option<Symbol> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<BeforeUnloadEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: BeforeUnloadEvent ) -> Result<Reference, <Reference as TryFrom<BeforeUnloadEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for AbortError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<AbortError, <AbortError as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SlotElement`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SlotElement, <SlotElement as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<PointerLockErrorEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerLockErrorEvent ) -> Result<Reference, <Reference as TryFrom<PointerLockErrorEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for OptionElement`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<OptionElement, <OptionElement as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for History`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<History, <History as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragStartEvent, <DragStartEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<ProgressErrorEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ProgressErrorEvent ) -> Result<Reference, <Reference as TryFrom<ProgressErrorEvent>>::Error>`[src]

`impl TryFrom<Value> for BeforeUnloadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<BeforeUnloadEvent, <BeforeUnloadEvent as TryFrom<Value>>::Error>`[src]

`impl<E, V> TryFrom<Object> for HashMap<String, V, RandomState> where E: Into<ConversionError>, V: TryFrom<Value, Error = E>,` [src]

`type Error = ConversionError`

`fn try_from( object: Object ) -> Result<HashMap<String, V, RandomState>, <HashMap<String, V, RandomState> as TryFrom<Object>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for MouseMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<MouseMoveEvent, <MouseMoveEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Symbol> for Value`[src]

`type Error = Void`

`fn try_from(source: Symbol) -> Result<Value, <Value as TryFrom<Symbol>>::Error>`[src]

`impl TryFrom<HtmlElement> for InputElement`[src]

`type Error = ConversionError`

`fn try_from( value: HtmlElement ) -> Result<InputElement, <InputElement as TryFrom<HtmlElement>>::Error>`[src]

`impl TryFrom<ContextMenuEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ContextMenuEvent ) -> Result<Reference, <Reference as TryFrom<ContextMenuEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DomException`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DomException, <DomException as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for SlotElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SlotElement, <SlotElement as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<TypeError> for Reference`[src]

`type Error = Void`

`fn try_from( value: TypeError ) -> Result<Reference, <Reference as TryFrom<TypeError>>::Error>`[src]

`impl TryFrom<TokenList> for Reference`[src]

`type Error = Void`

`fn try_from( value: TokenList ) -> Result<Reference, <Reference as TryFrom<TokenList>>::Error>`[src]

`impl TryFrom<MouseEvent> for PointerMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<PointerMoveEvent, <PointerMoveEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for FileReader`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<FileReader, <FileReader as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for Value`[src]

`type Error = Void`

`fn try_from( source: Reference ) -> Result<Value, <Value as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for PointerOutEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerOutEvent, <PointerOutEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for NotFoundError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<NotFoundError, <NotFoundError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for ProgressEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ProgressEvent, <ProgressEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<ProgressRelatedEvent> for LoadEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: ProgressRelatedEvent ) -> Result<LoadEndEvent, <LoadEndEvent as TryFrom<ProgressRelatedEvent>>::Error>`[src]

`impl TryFrom<InputElement> for Reference`[src]

`type Error = Void`

`fn try_from( value: InputElement ) -> Result<Reference, <Reference as TryFrom<InputElement>>::Error>`[src]

`impl TryFrom<Reference> for PopStateEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PopStateEvent, <PopStateEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for LoadEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<LoadEndEvent, <LoadEndEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DataTransfer`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DataTransfer, <DataTransfer as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r, T> TryFrom<&'_r Value> for TypedArray<T> where T: ArrayKind,` [src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TypedArray<T>, <TypedArray<T> as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<PointerEvent> for PointerDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl TryFrom<LoadEndEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: LoadEndEvent ) -> Result<Reference, <Reference as TryFrom<LoadEndEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DocumentFragment`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DocumentFragment, <DocumentFragment as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for MouseMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<MouseMoveEvent, <MouseMoveEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Value> for FormDataEntry`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<FormDataEntry, <FormDataEntry as TryFrom<Value>>::Error>`[src]

`impl TryFrom<PointerOverEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerOverEvent ) -> Result<Reference, <Reference as TryFrom<PointerOverEvent>>::Error>`[src]

`impl TryFrom<Selection> for Reference`[src]

`type Error = Void`

`fn try_from( value: Selection ) -> Result<Reference, <Reference as TryFrom<Selection>>::Error>`[src]

`impl TryFrom<Event> for ResourceAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ResourceAbortEvent, <ResourceAbortEvent as TryFrom<Event>>::Error>`[src]

`impl<T> TryFrom<Vec<T>> for Array where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from(source: Vec<T>) -> Result<Array, <Array as TryFrom<Vec<T>>>::Error>`[src]

`impl TryFrom<Reference> for MutationObserver`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<MutationObserver, <MutationObserver as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for AuxClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<AuxClickEvent, <AuxClickEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ResourceLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ResourceLoadEvent, <ResourceLoadEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for KeyDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<KeyDownEvent, <KeyDownEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for SlotChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SlotChangeEvent, <SlotChangeEvent as TryFrom<Reference>>::Error>`[src]

`impl<'a> TryFrom<&'a Undefined> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a Undefined ) -> Result<Value, <Value as TryFrom<&'a Undefined>>::Error>`[src]

`impl TryFrom<i32> for Number`[src]

`type Error = Void`

`fn try_from(value: i32) -> Result<Number, <Number as TryFrom<i32>>::Error>`[src]

`impl TryFrom<Node> for ShadowRoot`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<ShadowRoot, <ShadowRoot as TryFrom<Node>>::Error>`[src]

`impl TryFrom<Value> for HtmlCollection`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<HtmlCollection, <HtmlCollection as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Element> for InputElement`[src]

`type Error = ConversionError`

`fn try_from( value: Element ) -> Result<InputElement, <InputElement as TryFrom<Element>>::Error>`[src]

`impl TryFrom<Event> for ResourceLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ResourceLoadEvent, <ResourceLoadEvent as TryFrom<Event>>::Error>`[src]

`impl<'a, T> TryFrom<&'a mut Vec<T>> for Array where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a mut Vec<T> ) -> Result<Array, <Array as TryFrom<&'a mut Vec<T>>>::Error>`[src]

`impl TryFrom<Reference> for ResizeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ResizeEvent, <ResizeEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<TextMetrics> for Reference`[src]

`type Error = Void`

`fn try_from( value: TextMetrics ) -> Result<Reference, <Reference as TryFrom<TextMetrics>>::Error>`[src]

`impl TryFrom<Reference> for DragStartEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DragStartEvent, <DragStartEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TextAreaElement`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TextAreaElement, <TextAreaElement as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for SelectionChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<SelectionChangeEvent, <SelectionChangeEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for SelectionChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SelectionChangeEvent, <SelectionChangeEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for SyntaxError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SyntaxError, <SyntaxError as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SocketMessageEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SocketMessageEvent, <SocketMessageEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: UiEvent ) -> Result<Reference, <Reference as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<DragRelatedEvent> for DragDropEvent`[src]

`type Error = ConversionError`

`fn try_from( value: DragRelatedEvent ) -> Result<DragDropEvent, <DragDropEvent as TryFrom<DragRelatedEvent>>::Error>`[src]

`impl TryFrom<Value> for DomException`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DomException, <DomException as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for bool`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<bool, <bool as TryFrom<Value>>::Error>`[src]

`impl TryFrom<EventTarget> for WebSocket`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<WebSocket, <WebSocket as TryFrom<EventTarget>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for HtmlElement`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<HtmlElement, <HtmlElement as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for Date`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Date, <Date as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<PointerOutEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerOutEvent ) -> Result<Reference, <Reference as TryFrom<PointerOutEvent>>::Error>`[src]

`impl TryFrom<Reference> for TextAreaElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TextAreaElement, <TextAreaElement as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<ShadowRoot> for Reference`[src]

`type Error = Void`

`fn try_from( value: ShadowRoot ) -> Result<Reference, <Reference as TryFrom<ShadowRoot>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DataTransferItemList`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DataTransferItemList, <DataTransferItemList as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for SlotChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<SlotChangeEvent, <SlotChangeEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<UiEvent> for LostPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<LostPointerCaptureEvent, <LostPointerCaptureEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Value> for Option<String>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<String>, <Option<String> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<ResourceAbortEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ResourceAbortEvent ) -> Result<Reference, <Reference as TryFrom<ResourceAbortEvent>>::Error>`[src]

`impl TryFrom<Value> for SocketMessageData`[src]

`type Error = ConversionError`

`fn try_from(v: Value) -> Result<SocketMessageData, ConversionError>`[src]

`impl<'_r> TryFrom<&'_r Value> for Window`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Window, <Window as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<SlotChangeEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: SlotChangeEvent ) -> Result<Reference, <Reference as TryFrom<SlotChangeEvent>>::Error>`[src]

`impl TryFrom<Value> for BlurEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<BlurEvent, <BlurEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for EventTarget`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<EventTarget, <EventTarget as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for InputElement`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<InputElement, <InputElement as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<UiEvent> for TouchEnter`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<TouchEnter, <TouchEnter as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<SocketErrorEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: SocketErrorEvent ) -> Result<Reference, <Reference as TryFrom<SocketErrorEvent>>::Error>`[src]

`impl TryFrom<Event> for ReadyStateChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ReadyStateChangeEvent, <ReadyStateChangeEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<CanvasPattern> for Reference`[src]

`type Error = Void`

`fn try_from( value: CanvasPattern ) -> Result<Reference, <Reference as TryFrom<CanvasPattern>>::Error>`[src]

`impl TryFrom<Reference> for ShadowRoot`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ShadowRoot, <ShadowRoot as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SelectElement`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SelectElement, <SelectElement as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ArrayBuffer`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ArrayBuffer, <ArrayBuffer as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for PointerLockErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerLockErrorEvent, <PointerLockErrorEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<UiEvent> for PointerCancelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<PointerCancelEvent, <PointerCancelEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Reference> for TextMetrics`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TextMetrics, <TextMetrics as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for CanvasRenderingContext2d`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<CanvasRenderingContext2d, <CanvasRenderingContext2d as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TextMetrics`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TextMetrics, <TextMetrics as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for IndexSizeError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<IndexSizeError, <IndexSizeError as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for TouchCancel`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<TouchCancel, <TouchCancel as TryFrom<Event>>::Error>`[src]

`impl<'a, K, V> TryFrom<&'a HashMap<K, V, RandomState>> for Value where K: AsRef<str> + Eq + Hash, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a HashMap<K, V, RandomState> ) -> Result<Value, <Value as TryFrom<&'a HashMap<K, V, RandomState>>>::Error>`[src]

`impl<'a> TryFrom<&'a str> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a str ) -> Result<Value, <Value as TryFrom<&'a str>>::Error>`[src]

`impl TryFrom<Event> for GamepadConnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<GamepadConnectedEvent, <GamepadConnectedEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<EventTarget> for HtmlElement`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<HtmlElement, <HtmlElement as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<MouseEvent> for MouseEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<MouseEnterEvent, <MouseEnterEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<PointerEvent> for PointerUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<PointerUpEvent, <PointerUpEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl TryFrom<MouseDownEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseDownEvent ) -> Result<Reference, <Reference as TryFrom<MouseDownEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for LostPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<LostPointerCaptureEvent, <LostPointerCaptureEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<History> for Reference`[src]

`type Error = Void`

`fn try_from( value: History ) -> Result<Reference, <Reference as TryFrom<History>>::Error>`[src]

`impl TryFrom<Value> for SocketErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SocketErrorEvent, <SocketErrorEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<f64> for Number`[src]

`type Error = Void`

`fn try_from(value: f64) -> Result<Number, <Number as TryFrom<f64>>::Error>`[src]

`impl TryFrom<Reference> for ProgressEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ProgressEvent, <ProgressEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ReadyStateChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ReadyStateChangeEvent, <ReadyStateChangeEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<KeyboardEvent> for KeyDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: KeyboardEvent ) -> Result<KeyDownEvent, <KeyDownEvent as TryFrom<KeyboardEvent>>::Error>`[src]

`impl TryFrom<Event> for DragDropEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DragDropEvent, <DragDropEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<CanvasElement> for Reference`[src]

`type Error = Void`

`fn try_from( value: CanvasElement ) -> Result<Reference, <Reference as TryFrom<CanvasElement>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Blob`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Blob, <Blob as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Blob> for Reference`[src]

`type Error = Void`

`fn try_from( value: Blob ) -> Result<Reference, <Reference as TryFrom<Blob>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for NotFoundError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<NotFoundError, <NotFoundError as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<EventTarget> for TemplateElement`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<TemplateElement, <TemplateElement as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Value> for SlotChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SlotChangeEvent, <SlotChangeEvent as TryFrom<Value>>::Error>`[src]

`impl<E, V> TryFrom<Object> for BTreeMap<String, V> where E: Into<ConversionError>, V: TryFrom<Value, Error = E>,` [src]

`type Error = ConversionError`

`fn try_from( object: Object ) -> Result<BTreeMap<String, V>, <BTreeMap<String, V> as TryFrom<Object>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for HierarchyRequestError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<HierarchyRequestError, <HierarchyRequestError as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<SocketOpenEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: SocketOpenEvent ) -> Result<Reference, <Reference as TryFrom<SocketOpenEvent>>::Error>`[src]

`impl<V> TryFrom<Value> for Option<HashMap<String, V, RandomState>> where V: TryFrom<Value, Error = ConversionError>,` [src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<HashMap<String, V, RandomState>>, <Option<HashMap<String, V, RandomState>> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<UiEvent> for DragEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DragEndEvent, <DragEndEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Event> for ProgressErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ProgressErrorEvent, <ProgressErrorEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Event> for GotPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<Event>>::Error>`[src]

`impl<'a, T> TryFrom<&'a [T]> for Array where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a [T] ) -> Result<Array, <Array as TryFrom<&'a [T]>>::Error>`[src]

`impl TryFrom<Value> for MouseWheelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<MouseWheelEvent, <MouseWheelEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Touch> for Reference`[src]

`type Error = Void`

`fn try_from( value: Touch ) -> Result<Reference, <Reference as TryFrom<Touch>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ClickEvent, <ClickEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<u8> for Number`[src]

`type Error = Void`

`fn try_from(value: u8) -> Result<Number, <Number as TryFrom<u8>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for FocusEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<FocusEvent, <FocusEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for LoadEndEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<LoadEndEvent, <LoadEndEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Gamepad`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Gamepad, <Gamepad as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Event> for TouchLeave`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<TouchLeave, <TouchLeave as TryFrom<Event>>::Error>`[src]

`impl TryFrom<EventTarget> for Node`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<Node, <Node as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<DocumentFragment> for Reference`[src]

`type Error = Void`

`fn try_from( value: DocumentFragment ) -> Result<Reference, <Reference as TryFrom<DocumentFragment>>::Error>`[src]

`impl TryFrom<Value> for PointerOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerOverEvent, <PointerOverEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ImageElement`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ImageElement, <ImageElement as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for TextMetrics`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TextMetrics, <TextMetrics as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ResizeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ResizeEvent, <ResizeEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<DomException> for InvalidAccessError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<InvalidAccessError, <InvalidAccessError as TryFrom<DomException>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DragStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DragStartEvent, <DragStartEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragExitEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragExitEvent, <DragExitEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for CanvasElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<CanvasElement, <CanvasElement as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for AuxClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<AuxClickEvent, <AuxClickEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for InputEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<InputEvent, <InputEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for Storage`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Storage, <Storage as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<MouseEvent> for MouseLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<MouseLeaveEvent, <MouseLeaveEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for MouseOverEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<MouseOverEvent, <MouseOverEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<AuxClickEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: AuxClickEvent ) -> Result<Reference, <Reference as TryFrom<AuxClickEvent>>::Error>`[src]

`impl TryFrom<Value> for ()`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<(), <() as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for ScrollEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ScrollEvent, <ScrollEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ProgressAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ProgressAbortEvent, <ProgressAbortEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<NodeList> for Reference`[src]

`type Error = Void`

`fn try_from( value: NodeList ) -> Result<Reference, <Reference as TryFrom<NodeList>>::Error>`[src]

`impl TryFrom<Reference> for Node`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Node, <Node as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for DragRelatedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragRelatedEvent, <DragRelatedEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for GamepadButton`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<GamepadButton, <GamepadButton as TryFrom<Value>>::Error>`[src]

`impl TryFrom<HtmlElement> for SelectElement`[src]

`type Error = ConversionError`

`fn try_from( value: HtmlElement ) -> Result<SelectElement, <SelectElement as TryFrom<HtmlElement>>::Error>`[src]

`impl TryFrom<Value> for InvalidAccessError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<InvalidAccessError, <InvalidAccessError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for PointerUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerUpEvent, <PointerUpEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<KeyboardEvent> for KeyPressEvent`[src]

`type Error = ConversionError`

`fn try_from( value: KeyboardEvent ) -> Result<KeyPressEvent, <KeyPressEvent as TryFrom<KeyboardEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for MouseLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<MouseLeaveEvent, <MouseLeaveEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'a> TryFrom<&'a mut char> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a mut char ) -> Result<Value, <Value as TryFrom<&'a mut char>>::Error>`[src]

`impl TryFrom<EventTarget> for Document`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<Document, <Document as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Reference> for SocketOpenEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SocketOpenEvent, <SocketOpenEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for usize`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<usize, <usize as TryFrom<Value>>::Error>`[src]

`impl TryFrom<TouchEnter> for Reference`[src]

`type Error = Void`

`fn try_from( value: TouchEnter ) -> Result<Reference, <Reference as TryFrom<TouchEnter>>::Error>`[src]

`impl TryFrom<Reference> for ReadyStateChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ReadyStateChangeEvent, <ReadyStateChangeEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Number> for i64`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<i64, <i64 as TryFrom<Number>>::Error>`[src]

`impl TryFrom<MouseEvent> for MouseUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<MouseUpEvent, <MouseUpEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Value> for Blob`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Blob, <Blob as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ResizeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ResizeEvent, <ResizeEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for LoadEndEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<LoadEndEvent, <LoadEndEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<SocketMessageEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: SocketMessageEvent ) -> Result<Reference, <Reference as TryFrom<SocketMessageEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for CanvasElement`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<CanvasElement, <CanvasElement as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for Value`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Value, <Value as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for PointerLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerLeaveEvent, <PointerLeaveEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for TouchEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<TouchEvent, <TouchEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'a> TryFrom<&'a Value> for &'a str`[src]

`type Error = ConversionError`

`fn try_from( value: &'a Value ) -> Result<&'a str, <&'a str as TryFrom<&'a Value>>::Error>`[src]

`impl TryFrom<Value> for i16`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<i16, <i16 as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Node> for SelectElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<SelectElement, <SelectElement as TryFrom<Node>>::Error>`[src]

`impl TryFrom<Value> for SocketReadyState`[src]

`type Error = ConversionError`

`fn try_from(v: Value) -> Result<SocketReadyState, ConversionError>`[src]

Performs the conversion.

`impl TryFrom<LoadStartEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: LoadStartEvent ) -> Result<Reference, <Reference as TryFrom<LoadStartEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SelectionChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SelectionChangeEvent, <SelectionChangeEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for BlurEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<BlurEvent, <BlurEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for KeyPressEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<KeyPressEvent, <KeyPressEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<DragDropEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DragDropEvent ) -> Result<Reference, <Reference as TryFrom<DragDropEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SocketCloseEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SocketCloseEvent, <SocketCloseEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for UnloadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<UnloadEvent, <UnloadEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<EventTarget> for OptionElement`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<OptionElement, <OptionElement as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Value> for CanvasPattern`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<CanvasPattern, <CanvasPattern as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for HashChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<HashChangeEvent, <HashChangeEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for MouseWheelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<MouseWheelEvent, <MouseWheelEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerLeaveEvent, <PointerLeaveEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<UiEvent> for MouseDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<MouseDownEvent, <MouseDownEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<OptionElement> for Reference`[src]

`type Error = Void`

`fn try_from( value: OptionElement ) -> Result<Reference, <Reference as TryFrom<OptionElement>>::Error>`[src]

`impl TryFrom<Element> for Reference`[src]

`type Error = Void`

`fn try_from( value: Element ) -> Result<Reference, <Reference as TryFrom<Element>>::Error>`[src]

`impl TryFrom<Reference> for ProgressErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ProgressErrorEvent, <ProgressErrorEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for TouchLeave`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TouchLeave, <TouchLeave as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<ProgressRelatedEvent> for ProgressLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: ProgressRelatedEvent ) -> Result<ProgressLoadEvent, <ProgressLoadEvent as TryFrom<ProgressRelatedEvent>>::Error>`[src]

`impl TryFrom<ChangeEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ChangeEvent ) -> Result<Reference, <Reference as TryFrom<ChangeEvent>>::Error>`[src]

`impl TryFrom<Reference> for ImageData`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ImageData, <ImageData as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<ProgressRelatedEvent> for ProgressEvent`[src]

`type Error = ConversionError`

`fn try_from( value: ProgressRelatedEvent ) -> Result<ProgressEvent, <ProgressEvent as TryFrom<ProgressRelatedEvent>>::Error>`[src]

`impl TryFrom<ProgressAbortEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ProgressAbortEvent ) -> Result<Reference, <Reference as TryFrom<ProgressAbortEvent>>::Error>`[src]

`impl TryFrom<Element> for ImageElement`[src]

`type Error = ConversionError`

`fn try_from( value: Element ) -> Result<ImageElement, <ImageElement as TryFrom<Element>>::Error>`[src]

`impl TryFrom<EventTarget> for SlotElement`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<SlotElement, <SlotElement as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<EventTarget> for TextNode`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<TextNode, <TextNode as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Value> for ResourceLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ResourceLoadEvent, <ResourceLoadEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for ContextMenuEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ContextMenuEvent, <ContextMenuEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for FormData`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<FormData, <FormData as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SocketOpenEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SocketOpenEvent, <SocketOpenEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for XmlHttpRequest`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<XmlHttpRequest, <XmlHttpRequest as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DataTransfer`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DataTransfer, <DataTransfer as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ProgressEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ProgressEvent, <ProgressEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ContextMenuEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ContextMenuEvent, <ContextMenuEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TouchEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TouchEvent, <TouchEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<PointerEvent> for PointerMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<PointerMoveEvent, <PointerMoveEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl TryFrom<TouchCancel> for Reference`[src]

`type Error = Void`

`fn try_from( value: TouchCancel ) -> Result<Reference, <Reference as TryFrom<TouchCancel>>::Error>`[src]

`impl TryFrom<Reference> for Window`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Window, <Window as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ScrollEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ScrollEvent, <ScrollEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for CanvasRenderingContext2d`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<CanvasRenderingContext2d, <CanvasRenderingContext2d as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerEnterEvent, <PointerEnterEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for LostPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<LostPointerCaptureEvent, <LostPointerCaptureEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Node> for TextNode`[src]

`type Error = ConversionError`

`fn try_from(value: Node) -> Result<TextNode, <TextNode as TryFrom<Node>>::Error>`[src]

`impl TryFrom<Node> for DocumentFragment`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<DocumentFragment, <DocumentFragment as TryFrom<Node>>::Error>`[src]

`impl TryFrom<TouchEvent> for TouchEnter`[src]

`type Error = ConversionError`

`fn try_from( value: TouchEvent ) -> Result<TouchEnter, <TouchEnter as TryFrom<TouchEvent>>::Error>`[src]

`impl TryFrom<Object> for Reference`[src]

`type Error = Void`

`fn try_from( value: Object ) -> Result<Reference, <Reference as TryFrom<Object>>::Error>`[src]

`impl TryFrom<MouseEvent> for ContextMenuEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<ContextMenuEvent, <ContextMenuEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<MouseEvent> for PointerCancelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<PointerCancelEvent, <PointerCancelEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for MouseDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<MouseDownEvent, <MouseDownEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<UiEvent> for DragEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DragEvent, <DragEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerLockChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerLockChangeEvent, <PointerLockChangeEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for PointerOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerOverEvent, <PointerOverEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for TypeError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TypeError, <TypeError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for MouseUpEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<MouseUpEvent, <MouseUpEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TextMetrics`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TextMetrics, <TextMetrics as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Node`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Node, <Node as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Number> for i16`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<i16, <i16 as TryFrom<Number>>::Error>`[src]

`impl TryFrom<DomException> for InvalidStateError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<InvalidStateError, <InvalidStateError as TryFrom<DomException>>::Error>`[src]

`impl TryFrom<KeyPressEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: KeyPressEvent ) -> Result<Reference, <Reference as TryFrom<KeyPressEvent>>::Error>`[src]

`impl TryFrom<Event> for PointerLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerLeaveEvent, <PointerLeaveEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<UiEvent> for PointerOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<PointerOutEvent, <PointerOutEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Reference> for MouseLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<MouseLeaveEvent, <MouseLeaveEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for CanvasRenderingContext2d`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<CanvasRenderingContext2d, <CanvasRenderingContext2d as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for PointerDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<UiEvent> for PointerEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<PointerEnterEvent, <PointerEnterEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Error> for TypeError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<TypeError, <TypeError as TryFrom<Error>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for CanvasPattern`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<CanvasPattern, <CanvasPattern as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<InputEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: InputEvent ) -> Result<Reference, <Reference as TryFrom<InputEvent>>::Error>`[src]

`impl TryFrom<MouseEvent> for PointerDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Value> for TouchStart`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TouchStart, <TouchStart as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ChangeEvent, <ChangeEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for TouchEnter`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TouchEnter, <TouchEnter as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for MouseMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<MouseMoveEvent, <MouseMoveEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerMoveEvent, <PointerMoveEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for NotSupportedError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<NotSupportedError, <NotSupportedError as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for DragExitEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DragExitEvent, <DragExitEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for SocketErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<SocketErrorEvent, <SocketErrorEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Promise> for Reference`[src]

`type Error = Void`

`fn try_from( value: Promise ) -> Result<Reference, <Reference as TryFrom<Promise>>::Error>`[src]

`impl TryFrom<Value> for InvalidCharacterError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<InvalidCharacterError, <InvalidCharacterError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for PointerEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerEnterEvent, <PointerEnterEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for LoadEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<LoadEndEvent, <LoadEndEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<MouseUpEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseUpEvent ) -> Result<Reference, <Reference as TryFrom<MouseUpEvent>>::Error>`[src]

`impl TryFrom<Value> for GotPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for BeforeUnloadEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<BeforeUnloadEvent, <BeforeUnloadEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<HtmlElement> for ImageElement`[src]

`type Error = ConversionError`

`fn try_from( value: HtmlElement ) -> Result<ImageElement, <ImageElement as TryFrom<HtmlElement>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for IndexSizeError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<IndexSizeError, <IndexSizeError as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<DragEndEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DragEndEvent ) -> Result<Reference, <Reference as TryFrom<DragEndEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for ContextMenuEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<ContextMenuEvent, <ContextMenuEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Reference> for ResourceAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ResourceAbortEvent, <ResourceAbortEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<EventTarget> for ImageElement`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<ImageElement, <ImageElement as TryFrom<EventTarget>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Element`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Element, <Element as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SyntaxError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SyntaxError, <SyntaxError as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for GamepadDisconnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<GamepadDisconnectedEvent, <GamepadDisconnectedEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ProgressEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ProgressEvent, <ProgressEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for Window`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Window, <Window as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for ResourceErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ResourceErrorEvent, <ResourceErrorEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragEndEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragEndEvent, <DragEndEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<InvalidAccessError> for Reference`[src]

`type Error = Void`

`fn try_from( value: InvalidAccessError ) -> Result<Reference, <Reference as TryFrom<InvalidAccessError>>::Error>`[src]

`impl TryFrom<Reference> for Object`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Object, <Object as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for DragRelatedEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DragRelatedEvent, <DragRelatedEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ProgressLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ProgressLoadEvent, <ProgressLoadEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<DragRelatedEvent> for DragEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: DragRelatedEvent ) -> Result<DragEndEvent, <DragEndEvent as TryFrom<DragRelatedEvent>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragLeaveEvent, <DragLeaveEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerOverEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerOverEvent, <PointerOverEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<ProgressRelatedEvent> for LoadStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: ProgressRelatedEvent ) -> Result<LoadStartEvent, <LoadStartEvent as TryFrom<ProgressRelatedEvent>>::Error>`[src]

`impl TryFrom<MouseMoveEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseMoveEvent ) -> Result<Reference, <Reference as TryFrom<MouseMoveEvent>>::Error>`[src]

`impl<T> TryFrom<Value> for Option<T> where T: TryFrom<Value, Error = ConversionError> + AsRef<Reference>,` [src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<T>, <Option<T> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<PointerEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerEvent ) -> Result<Reference, <Reference as TryFrom<PointerEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for WebSocket`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<WebSocket, <WebSocket as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'a, K, V> TryFrom<&'a mut HashMap<K, V, RandomState>> for Value where K: AsRef<str> + Eq + Hash, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a mut HashMap<K, V, RandomState> ) -> Result<Value, <Value as TryFrom<&'a mut HashMap<K, V, RandomState>>>::Error>`[src]

`impl TryFrom<Value> for Reference`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Reference, <Reference as TryFrom<Value>>::Error>`[src]

`impl TryFrom<CanvasRenderingContext2d> for Reference`[src]

`type Error = Void`

`fn try_from( value: CanvasRenderingContext2d ) -> Result<Reference, <Reference as TryFrom<CanvasRenderingContext2d>>::Error>`[src]

`impl TryFrom<Error> for InvalidAccessError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<InvalidAccessError, <InvalidAccessError as TryFrom<Error>>::Error>`[src]

`impl TryFrom<PointerEvent> for PointerOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<PointerOutEvent, <PointerOutEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl TryFrom<ProgressEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ProgressEvent ) -> Result<Reference, <Reference as TryFrom<ProgressEvent>>::Error>`[src]

`impl TryFrom<Reference> for DocumentFragment`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DocumentFragment, <DocumentFragment as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for UnloadEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<UnloadEvent, <UnloadEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for PointerOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerOutEvent, <PointerOutEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<GamepadConnectedEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: GamepadConnectedEvent ) -> Result<Reference, <Reference as TryFrom<GamepadConnectedEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for InvalidAccessError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<InvalidAccessError, <InvalidAccessError as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<TouchEvent> for TouchLeave`[src]

`type Error = ConversionError`

`fn try_from( value: TouchEvent ) -> Result<TouchLeave, <TouchLeave as TryFrom<TouchEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for TouchEnd`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<TouchEnd, <TouchEnd as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for CanvasGradient`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<CanvasGradient, <CanvasGradient as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Node> for Reference`[src]

`type Error = Void`

`fn try_from( value: Node ) -> Result<Reference, <Reference as TryFrom<Node>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for LoadStartEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<LoadStartEvent, <LoadStartEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for File`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<File, <File as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for Error`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Error, <Error as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for ReadyStateChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ReadyStateChangeEvent, <ReadyStateChangeEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for MouseDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<MouseDownEvent, <MouseDownEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<KeyboardEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: KeyboardEvent ) -> Result<Reference, <Reference as TryFrom<KeyboardEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ProgressErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ProgressErrorEvent, <ProgressErrorEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<i8> for Value`[src]

`type Error = Void`

`fn try_from(source: i8) -> Result<Value, <Value as TryFrom<i8>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for HashChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<HashChangeEvent, <HashChangeEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TouchMove`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TouchMove, <TouchMove as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'a> TryFrom<&'a mut bool> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a mut bool ) -> Result<Value, <Value as TryFrom<&'a mut bool>>::Error>`[src]

`impl TryFrom<f32> for Number`[src]

`type Error = Void`

`fn try_from(value: f32) -> Result<Number, <Number as TryFrom<f32>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerLockErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerLockErrorEvent, <PointerLockErrorEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for NotFoundError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<NotFoundError, <NotFoundError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for Object`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Object, <Object as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for CanvasPattern`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<CanvasPattern, <CanvasPattern as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ResourceErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ResourceErrorEvent, <ResourceErrorEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for FormData`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<FormData, <FormData as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for DragEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragEndEvent, <DragEndEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for MouseOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<MouseOverEvent, <MouseOverEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<DomException> for NotFoundError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<NotFoundError, <NotFoundError as TryFrom<DomException>>::Error>`[src]

`impl TryFrom<EventTarget> for TextAreaElement`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<TextAreaElement, <TextAreaElement as TryFrom<EventTarget>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for HtmlCollection`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<HtmlCollection, <HtmlCollection as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'a, T> TryFrom<&'a mut Vec<T>> for Value where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a mut Vec<T> ) -> Result<Value, <Value as TryFrom<&'a mut Vec<T>>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Storage`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Storage, <Storage as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for GamepadDisconnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<GamepadDisconnectedEvent, <GamepadDisconnectedEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for MouseWheelEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<MouseWheelEvent, <MouseWheelEvent as TryFrom<Reference>>::Error>`[src]

`impl<K, V> TryFrom<BTreeMap<K, V>> for Value where K: AsRef<str>, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: BTreeMap<K, V> ) -> Result<Value, <Value as TryFrom<BTreeMap<K, V>>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for EventTarget`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<EventTarget, <EventTarget as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for HierarchyRequestError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<HierarchyRequestError, <HierarchyRequestError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<f64> for Value`[src]

`type Error = Void`

`fn try_from(source: f64) -> Result<Value, <Value as TryFrom<f64>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SocketCloseEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SocketCloseEvent, <SocketCloseEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for LoadStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<LoadStartEvent, <LoadStartEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for SecurityError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SecurityError, <SecurityError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for MouseWheelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<MouseWheelEvent, <MouseWheelEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TouchLeave`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TouchLeave, <TouchLeave as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<i16> for Value`[src]

`type Error = Void`

`fn try_from(source: i16) -> Result<Value, <Value as TryFrom<i16>>::Error>`[src]

`impl TryFrom<Value> for AddColorStopError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<AddColorStopError, <AddColorStopError as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for HashChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<HashChangeEvent, <HashChangeEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for HtmlElement`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<HtmlElement, <HtmlElement as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<GamepadEvent> for GamepadConnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: GamepadEvent ) -> Result<GamepadConnectedEvent, <GamepadConnectedEvent as TryFrom<GamepadEvent>>::Error>`[src]

`impl TryFrom<u32> for Value`[src]

`type Error = Void`

`fn try_from(source: u32) -> Result<Value, <Value as TryFrom<u32>>::Error>`[src]

`impl TryFrom<Reference> for Element`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Element, <Element as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerEnterEvent, <PointerEnterEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<K, V> TryFrom<BTreeMap<K, V>> for Object where K: AsRef<str>, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: BTreeMap<K, V> ) -> Result<Object, <Object as TryFrom<BTreeMap<K, V>>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for MutationObserver`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<MutationObserver, <MutationObserver as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<ProgressRelatedEvent> for ProgressErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: ProgressRelatedEvent ) -> Result<ProgressErrorEvent, <ProgressErrorEvent as TryFrom<ProgressRelatedEvent>>::Error>`[src]

`impl TryFrom<DomException> for HierarchyRequestError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<HierarchyRequestError, <HierarchyRequestError as TryFrom<DomException>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SecurityError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SecurityError, <SecurityError as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<u64> for Number`[src]

`type Error = ConversionError`

`fn try_from(value: u64) -> Result<Number, <Number as TryFrom<u64>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PopStateEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PopStateEvent, <PopStateEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Event> for DragStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DragStartEvent, <DragStartEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Node> for Element`[src]

`type Error = ConversionError`

`fn try_from(value: Node) -> Result<Element, <Element as TryFrom<Node>>::Error>`[src]

`impl TryFrom<Value> for String`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<String, <String as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for KeyPressEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<KeyPressEvent, <KeyPressEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Array> for Reference`[src]

`type Error = Void`

`fn try_from( value: Array ) -> Result<Reference, <Reference as TryFrom<Array>>::Error>`[src]

`impl TryFrom<Number> for u8`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<u8, <u8 as TryFrom<Number>>::Error>`[src]

`impl TryFrom<Value> for HashChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<HashChangeEvent, <HashChangeEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for ProgressAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ProgressAbortEvent, <ProgressAbortEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for SocketMessageEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SocketMessageEvent, <SocketMessageEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for InvalidCharacterError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<InvalidCharacterError, <InvalidCharacterError as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for MouseMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<MouseMoveEvent, <MouseMoveEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for PointerLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerLeaveEvent, <PointerLeaveEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Element> for TextAreaElement`[src]

`type Error = ConversionError`

`fn try_from( value: Element ) -> Result<TextAreaElement, <TextAreaElement as TryFrom<Element>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for NotSupportedError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<NotSupportedError, <NotSupportedError as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for FormData`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<FormData, <FormData as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<CanvasGradient> for Reference`[src]

`type Error = Void`

`fn try_from( value: CanvasGradient ) -> Result<Reference, <Reference as TryFrom<CanvasGradient>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for FocusEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<FocusEvent, <FocusEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<PointerUpEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerUpEvent ) -> Result<Reference, <Reference as TryFrom<PointerUpEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for MouseUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<MouseUpEvent, <MouseUpEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'a, T> TryFrom<&'a Vec<T>> for Array where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a Vec<T> ) -> Result<Array, <Array as TryFrom<&'a Vec<T>>>::Error>`[src]

`impl<'_r, T> TryFrom<&'_r Reference> for TypedArray<T> where T: ArrayKind,` [src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TypedArray<T>, <TypedArray<T> as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ImageData`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ImageData, <ImageData as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for DragEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DragEndEvent, <DragEndEvent as TryFrom<Event>>::Error>`[src]

`impl<'a> TryFrom<&'a Value> for &'a Symbol`[src]

`type Error = ConversionError`

`fn try_from( value: &'a Value ) -> Result<&'a Symbol, <&'a Symbol as TryFrom<&'a Value>>::Error>`[src]

`impl<'a, T> TryFrom<&'a mut Serde<T>> for Value where T: Serialize,` [src]

`type Error = ConversionError`

`fn try_from( value: &'a mut Serde<T> ) -> Result<Value, <Value as TryFrom<&'a mut Serde<T>>>::Error>`[src]

`impl<T> TryFrom<Value> for Option<Vec<T>> where T: TryFrom<Value, Error = ConversionError>,` [src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<Vec<T>>, <Option<Vec<T>> as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DataTransferItem`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DataTransferItem, <DataTransferItem as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SecurityError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SecurityError, <SecurityError as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for InputEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<InputEvent, <InputEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<DragEnterEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DragEnterEvent ) -> Result<Reference, <Reference as TryFrom<DragEnterEvent>>::Error>`[src]

`impl TryFrom<Reference> for Reference`[src]

`type Error = Void`

`fn try_from( source: Reference ) -> Result<Reference, <Reference as TryFrom<Reference>>::Error>`[src]

`impl<'a> TryFrom<&'a mut Undefined> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a mut Undefined ) -> Result<Value, <Value as TryFrom<&'a mut Undefined>>::Error>`[src]

`impl TryFrom<Value> for WebSocket`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<WebSocket, <WebSocket as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ClickEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ClickEvent, <ClickEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for IndexSizeError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<IndexSizeError, <IndexSizeError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for TouchMove`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<TouchMove, <TouchMove as TryFrom<UiEvent>>::Error>`[src]

`impl<'a, T> TryFrom<&'a Vec<T>> for Value where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a Vec<T> ) -> Result<Value, <Value as TryFrom<&'a Vec<T>>>::Error>`[src]

`impl TryFrom<Event> for PointerCancelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerCancelEvent, <PointerCancelEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragExitEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragExitEvent, <DragExitEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ImageData`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ImageData, <ImageData as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for KeyUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<KeyUpEvent, <KeyUpEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<PointerEvent> for PointerEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<PointerEnterEvent, <PointerEnterEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl TryFrom<TouchEnd> for Reference`[src]

`type Error = Void`

`fn try_from( value: TouchEnd ) -> Result<Reference, <Reference as TryFrom<TouchEnd>>::Error>`[src]

`impl TryFrom<Value> for Undefined`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Undefined, <Undefined as TryFrom<Value>>::Error>`[src]

`impl TryFrom<TextAreaElement> for Reference`[src]

`type Error = Void`

`fn try_from( value: TextAreaElement ) -> Result<Reference, <Reference as TryFrom<TextAreaElement>>::Error>`[src]

`impl TryFrom<Event> for MouseOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<MouseOverEvent, <MouseOverEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for InvalidStateError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<InvalidStateError, <InvalidStateError as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<LostPointerCaptureEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: LostPointerCaptureEvent ) -> Result<Reference, <Reference as TryFrom<LostPointerCaptureEvent>>::Error>`[src]

`impl TryFrom<DragRelatedEvent> for DragEvent`[src]

`type Error = ConversionError`

`fn try_from( value: DragRelatedEvent ) -> Result<DragEvent, <DragEvent as TryFrom<DragRelatedEvent>>::Error>`[src]

`impl TryFrom<XmlHttpRequest> for Reference`[src]

`type Error = Void`

`fn try_from( value: XmlHttpRequest ) -> Result<Reference, <Reference as TryFrom<XmlHttpRequest>>::Error>`[src]

`impl TryFrom<EventTarget> for FileReader`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<FileReader, <FileReader as TryFrom<EventTarget>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TextNode`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TextNode, <TextNode as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<UnloadEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: UnloadEvent ) -> Result<Reference, <Reference as TryFrom<UnloadEvent>>::Error>`[src]

`impl TryFrom<Reference> for SyntaxError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SyntaxError, <SyntaxError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for MouseOutEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<MouseOutEvent, <MouseOutEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for GamepadConnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<GamepadConnectedEvent, <GamepadConnectedEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for ClickEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ClickEvent, <ClickEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for SelectElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SelectElement, <SelectElement as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for Document`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Document, <Document as TryFrom<Value>>::Error>`[src]

`impl TryFrom<SlotElement> for Reference`[src]

`type Error = Void`

`fn try_from( value: SlotElement ) -> Result<Reference, <Reference as TryFrom<SlotElement>>::Error>`[src]

`impl TryFrom<MouseEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseEvent ) -> Result<Reference, <Reference as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Value> for AbortError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<AbortError, <AbortError as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ContextMenuEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ContextMenuEvent, <ContextMenuEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for UnloadEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<UnloadEvent, <UnloadEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<DragRelatedEvent> for DragLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: DragRelatedEvent ) -> Result<DragLeaveEvent, <DragLeaveEvent as TryFrom<DragRelatedEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for MouseOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<MouseOutEvent, <MouseOutEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for MouseWheelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<MouseWheelEvent, <MouseWheelEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for MouseLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<MouseLeaveEvent, <MouseLeaveEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for BeforeUnloadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<BeforeUnloadEvent, <BeforeUnloadEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Document> for Reference`[src]

`type Error = Void`

`fn try_from( value: Document ) -> Result<Reference, <Reference as TryFrom<Document>>::Error>`[src]

`impl TryFrom<DragRelatedEvent> for DragExitEvent`[src]

`type Error = ConversionError`

`fn try_from( value: DragRelatedEvent ) -> Result<DragExitEvent, <DragExitEvent as TryFrom<DragRelatedEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Selection`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Selection, <Selection as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for TouchEnd`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TouchEnd, <TouchEnd as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Blob> for File`[src]

`type Error = ConversionError`

`fn try_from(value: Blob) -> Result<File, <File as TryFrom<Blob>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Node`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Node, <Node as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<GamepadEvent> for GamepadDisconnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: GamepadEvent ) -> Result<GamepadDisconnectedEvent, <GamepadDisconnectedEvent as TryFrom<GamepadEvent>>::Error>`[src]

`impl TryFrom<Value> for InvalidStateError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<InvalidStateError, <InvalidStateError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for Touch`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Touch, <Touch as TryFrom<Value>>::Error>`[src]

`impl<'a, T> TryFrom<&'a mut [T]> for Value where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a mut [T] ) -> Result<Value, <Value as TryFrom<&'a mut [T]>>::Error>`[src]

`impl TryFrom<Reference> for LoadStartEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<LoadStartEvent, <LoadStartEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<ClickEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ClickEvent ) -> Result<Reference, <Reference as TryFrom<ClickEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for TouchCancel`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<TouchCancel, <TouchCancel as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<DragStartEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DragStartEvent ) -> Result<Reference, <Reference as TryFrom<DragStartEvent>>::Error>`[src]

`impl TryFrom<Value> for DragLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragLeaveEvent, <DragLeaveEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for KeyDownEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<KeyDownEvent, <KeyDownEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for InputEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<InputEvent, <InputEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<i64> for Value`[src]

`type Error = <Number as TryFrom<i64>>::Error`

`fn try_from(value: i64) -> Result<Value, <Value as TryFrom<i64>>::Error>`[src]

`impl TryFrom<Event> for DragExitEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DragExitEvent, <DragExitEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Error> for NotSupportedError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<NotSupportedError, <NotSupportedError as TryFrom<Error>>::Error>`[src]

`impl TryFrom<Error> for SyntaxError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<SyntaxError, <SyntaxError as TryFrom<Error>>::Error>`[src]

`impl TryFrom<Value> for MouseEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<MouseEnterEvent, <MouseEnterEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for DragOverEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DragOverEvent, <DragOverEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<IndexSizeError> for Reference`[src]

`type Error = Void`

`fn try_from( value: IndexSizeError ) -> Result<Reference, <Reference as TryFrom<IndexSizeError>>::Error>`[src]

`impl TryFrom<String> for Value`[src]

`type Error = Void`

`fn try_from(source: String) -> Result<Value, <Value as TryFrom<String>>::Error>`[src]

`impl TryFrom<Location> for Reference`[src]

`type Error = Void`

`fn try_from( value: Location ) -> Result<Reference, <Reference as TryFrom<Location>>::Error>`[src]

`impl TryFrom<SubmitEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: SubmitEvent ) -> Result<Reference, <Reference as TryFrom<SubmitEvent>>::Error>`[src]

`impl TryFrom<Reference> for NodeList`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<NodeList, <NodeList as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<KeyboardEvent> for KeyUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: KeyboardEvent ) -> Result<KeyUpEvent, <KeyUpEvent as TryFrom<KeyboardEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for ResourceErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<ResourceErrorEvent, <ResourceErrorEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<E, T> TryFrom<Value> for Vec<T> where E: Into<ConversionError>, T: TryFrom<Value, Error = E>,` [src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Vec<T>, <Vec<T> as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Rect`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Rect, <Rect as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for ProgressEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ProgressEvent, <ProgressEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for PointerDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<Value>>::Error>`[src]

`impl<T> TryFrom<Vec<T>> for Value where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from(source: Vec<T>) -> Result<Value, <Value as TryFrom<Vec<T>>>::Error>`[src]

`impl TryFrom<i32> for Value`[src]

`type Error = Void`

`fn try_from(source: i32) -> Result<Value, <Value as TryFrom<i32>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Touch`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Touch, <Touch as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<u16> for Number`[src]

`type Error = Void`

`fn try_from(value: u16) -> Result<Number, <Number as TryFrom<u16>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for MouseUpEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<MouseUpEvent, <MouseUpEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for FileList`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<FileList, <FileList as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for InvalidCharacterError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<InvalidCharacterError, <InvalidCharacterError as TryFrom<&'_r Value>>::Error>`[src]

`impl<'a, K, V> TryFrom<&'a HashMap<K, V, RandomState>> for Object where K: AsRef<str> + Eq + Hash, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a HashMap<K, V, RandomState> ) -> Result<Object, <Object as TryFrom<&'a HashMap<K, V, RandomState>>>::Error>`[src]

`impl TryFrom<Event> for KeyPressEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<KeyPressEvent, <KeyPressEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for TextAreaElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TextAreaElement, <TextAreaElement as TryFrom<Value>>::Error>`[src]

`impl TryFrom<UiEvent> for MouseEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<MouseEnterEvent, <MouseEnterEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'a, K, V> TryFrom<&'a BTreeMap<K, V>> for Value where K: AsRef<str>, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a BTreeMap<K, V> ) -> Result<Value, <Value as TryFrom<&'a BTreeMap<K, V>>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for InvalidStateError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<InvalidStateError, <InvalidStateError as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for StringMap`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<StringMap, <StringMap as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DragRelatedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DragRelatedEvent, <DragRelatedEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'a, K, V> TryFrom<&'a mut HashMap<K, V, RandomState>> for Object where K: AsRef<str> + Eq + Hash, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a mut HashMap<K, V, RandomState> ) -> Result<Object, <Object as TryFrom<&'a mut HashMap<K, V, RandomState>>>::Error>`[src]

`impl TryFrom<SocketCloseEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: SocketCloseEvent ) -> Result<Reference, <Reference as TryFrom<SocketCloseEvent>>::Error>`[src]

`impl TryFrom<Reference> for PointerUpEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerUpEvent, <PointerUpEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for Storage`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Storage, <Storage as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TouchEnter`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TouchEnter, <TouchEnter as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for DragEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DragEvent, <DragEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<DomException> for SyntaxError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<SyntaxError, <SyntaxError as TryFrom<DomException>>::Error>`[src]

`impl TryFrom<Value> for PointerLockChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerLockChangeEvent, <PointerLockChangeEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for KeyDownEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<KeyDownEvent, <KeyDownEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for TextNode`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TextNode, <TextNode as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for Rect`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Rect, <Rect as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for ClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ClickEvent, <ClickEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<PointerEvent> for PointerCancelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<PointerCancelEvent, <PointerCancelEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl<'a, K, V> TryFrom<&'a mut BTreeMap<K, V>> for Value where K: AsRef<str>, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a mut BTreeMap<K, V> ) -> Result<Value, <Value as TryFrom<&'a mut BTreeMap<K, V>>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for File`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<File, <File as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for CanvasElement`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<CanvasElement, <CanvasElement as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for MouseLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<MouseLeaveEvent, <MouseLeaveEvent as TryFrom<Event>>::Error>`[src]

`impl<'a, K, V> TryFrom<&'a mut BTreeMap<K, V>> for Object where K: AsRef<str>, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a mut BTreeMap<K, V> ) -> Result<Object, <Object as TryFrom<&'a mut BTreeMap<K, V>>>::Error>`[src]

`impl<E, V> TryFrom<Value> for BTreeMap<String, V> where E: Into<ConversionError>, V: TryFrom<Value, Error = E>,` [src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<BTreeMap<String, V>, <BTreeMap<String, V> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for DragOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragOverEvent, <DragOverEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for MouseWheelEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<MouseWheelEvent, <MouseWheelEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Selection`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Selection, <Selection as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<ResourceLoadEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ResourceLoadEvent ) -> Result<Reference, <Reference as TryFrom<ResourceLoadEvent>>::Error>`[src]

`impl TryFrom<DragEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DragEvent ) -> Result<Reference, <Reference as TryFrom<DragEvent>>::Error>`[src]

`impl TryFrom<Node> for Document`[src]

`type Error = ConversionError`

`fn try_from(value: Node) -> Result<Document, <Document as TryFrom<Node>>::Error>`[src]

`impl TryFrom<Event> for ClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ClickEvent, <ClickEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<PointerCancelEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerCancelEvent ) -> Result<Reference, <Reference as TryFrom<PointerCancelEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerCancelEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerCancelEvent, <PointerCancelEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for SocketCloseEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SocketCloseEvent, <SocketCloseEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Gamepad`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Gamepad, <Gamepad as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for SocketMessageEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<SocketMessageEvent, <SocketMessageEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<FormData> for Reference`[src]

`type Error = Void`

`fn try_from( value: FormData ) -> Result<Reference, <Reference as TryFrom<FormData>>::Error>`[src]

`impl TryFrom<Number> for u32`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<u32, <u32 as TryFrom<Number>>::Error>`[src]

`impl<'de, T> TryFrom<Value> for Option<Serde<T>> where T: Deserialize<'de>,` [src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<Serde<T>>, <Option<Serde<T>> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Date> for Reference`[src]

`type Error = Void`

`fn try_from( value: Date ) -> Result<Reference, <Reference as TryFrom<Date>>::Error>`[src]

`impl TryFrom<Event> for KeyDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<KeyDownEvent, <KeyDownEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<TouchMove> for Reference`[src]

`type Error = Void`

`fn try_from( value: TouchMove ) -> Result<Reference, <Reference as TryFrom<TouchMove>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TouchEnter`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TouchEnter, <TouchEnter as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for DragRelatedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DragRelatedEvent, <DragRelatedEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Value> for Option<bool>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<bool>, <Option<bool> as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ProgressAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ProgressAbortEvent, <ProgressAbortEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for InvalidStateError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<InvalidStateError, <InvalidStateError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for TextNode`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TextNode, <TextNode as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for UnloadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<UnloadEvent, <UnloadEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<EventTarget> for DocumentFragment`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<DocumentFragment, <DocumentFragment as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Reference> for CanvasRenderingContext2d`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<CanvasRenderingContext2d, <CanvasRenderingContext2d as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for DragDropEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DragDropEvent, <DragDropEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<DocumentFragment> for ShadowRoot`[src]

`type Error = ConversionError`

`fn try_from( value: DocumentFragment ) -> Result<ShadowRoot, <ShadowRoot as TryFrom<DocumentFragment>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TouchCancel`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TouchCancel, <TouchCancel as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<WebSocket> for Reference`[src]

`type Error = Void`

`fn try_from( value: WebSocket ) -> Result<Reference, <Reference as TryFrom<WebSocket>>::Error>`[src]

`impl TryFrom<Reference> for DataTransfer`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DataTransfer, <DataTransfer as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<DragRelatedEvent> for DragOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: DragRelatedEvent ) -> Result<DragOverEvent, <DragOverEvent as TryFrom<DragRelatedEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TypeError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TypeError, <TypeError as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SlotChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SlotChangeEvent, <SlotChangeEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for KeyUpEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<KeyUpEvent, <KeyUpEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for ChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ChangeEvent, <ChangeEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Event> for PointerLockChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerLockChangeEvent, <PointerLockChangeEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<DataTransfer> for Reference`[src]

`type Error = Void`

`fn try_from( value: DataTransfer ) -> Result<Reference, <Reference as TryFrom<DataTransfer>>::Error>`[src]

`impl TryFrom<UiEvent> for ResourceAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<ResourceAbortEvent, <ResourceAbortEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Event> for DragEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DragEnterEvent, <DragEnterEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Reference> for SocketErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SocketErrorEvent, <SocketErrorEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TextAreaElement`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TextAreaElement, <TextAreaElement as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for TouchMove`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TouchMove, <TouchMove as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for DoubleClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DoubleClickEvent, <DoubleClickEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragEvent, <DragEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Event> for ResourceErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ResourceErrorEvent, <ResourceErrorEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Event> for TouchStart`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<TouchStart, <TouchStart as TryFrom<Event>>::Error>`[src]

`impl TryFrom<TextNode> for Reference`[src]

`type Error = Void`

`fn try_from( value: TextNode ) -> Result<Reference, <Reference as TryFrom<TextNode>>::Error>`[src]

`impl TryFrom<Value> for LostPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<LostPointerCaptureEvent, <LostPointerCaptureEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for TouchCancel`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TouchCancel, <TouchCancel as TryFrom<Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for PointerUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<PointerUpEvent, <PointerUpEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Reference> for AuxClickEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<AuxClickEvent, <AuxClickEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for SocketMessageEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<SocketMessageEvent, <SocketMessageEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Element> for HtmlElement`[src]

`type Error = ConversionError`

`fn try_from( value: Element ) -> Result<HtmlElement, <HtmlElement as TryFrom<Element>>::Error>`[src]

`impl TryFrom<Reference> for DragLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DragLeaveEvent, <DragLeaveEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for AuxClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<AuxClickEvent, <AuxClickEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Document`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Document, <Document as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Event> for SubmitEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<SubmitEvent, <SubmitEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Event> for HashChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<HashChangeEvent, <HashChangeEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<HierarchyRequestError> for Reference`[src]

`type Error = Void`

`fn try_from( value: HierarchyRequestError ) -> Result<Reference, <Reference as TryFrom<HierarchyRequestError>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Element`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Element, <Element as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for TouchStart`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<TouchStart, <TouchStart as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for LostPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<LostPointerCaptureEvent, <LostPointerCaptureEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for TouchEnd`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TouchEnd, <TouchEnd as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for MouseEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<MouseEnterEvent, <MouseEnterEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ProgressLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ProgressLoadEvent, <ProgressLoadEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Event> for GamepadDisconnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<GamepadDisconnectedEvent, <GamepadDisconnectedEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for Option<u8>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<u8>, <Option<u8> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for PointerEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerEnterEvent, <PointerEnterEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Touch`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Touch, <Touch as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<i16> for Number`[src]

`type Error = Void`

`fn try_from(value: i16) -> Result<Number, <Number as TryFrom<i16>>::Error>`[src]

`impl TryFrom<Value> for ChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ChangeEvent, <ChangeEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for LoadStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<LoadStartEvent, <LoadStartEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StringMap`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<StringMap, <StringMap as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<DragRelatedEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DragRelatedEvent ) -> Result<Reference, <Reference as TryFrom<DragRelatedEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerUpEvent, <PointerUpEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for DragEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DragEnterEvent, <DragEnterEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for ShadowRoot`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ShadowRoot, <ShadowRoot as TryFrom<Value>>::Error>`[src]

`impl<'a> TryFrom<&'a Reference> for &'a Reference`[src]

`type Error = Void`

`fn try_from( source: &'a Reference ) -> Result<&'a Reference, <&'a Reference as TryFrom<&'a Reference>>::Error>`[src]

`impl<'a> TryFrom<&'a mut Null> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a mut Null ) -> Result<Value, <Value as TryFrom<&'a mut Null>>::Error>`[src]

`impl TryFrom<Value> for SocketCloseEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SocketCloseEvent, <SocketCloseEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<MouseOverEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseOverEvent ) -> Result<Reference, <Reference as TryFrom<MouseOverEvent>>::Error>`[src]

`impl TryFrom<Element> for SlotElement`[src]

`type Error = ConversionError`

`fn try_from( value: Element ) -> Result<SlotElement, <SlotElement as TryFrom<Element>>::Error>`[src]

`impl TryFrom<Value> for XhrSetResponseTypeError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<XhrSetResponseTypeError, <XhrSetResponseTypeError as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ShadowRoot`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ShadowRoot, <ShadowRoot as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'a> TryFrom<&'a Value> for Option<&'a Reference>`[src]

`type Error = ConversionError`

`fn try_from( value: &'a Value ) -> Result<Option<&'a Reference>, <Option<&'a Reference> as TryFrom<&'a Value>>::Error>`[src]

`impl TryFrom<Node> for CanvasElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<CanvasElement, <CanvasElement as TryFrom<Node>>::Error>`[src]

`impl TryFrom<Reference> for MouseDownEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<MouseDownEvent, <MouseDownEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<HashChangeEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: HashChangeEvent ) -> Result<Reference, <Reference as TryFrom<HashChangeEvent>>::Error>`[src]

`impl TryFrom<Event> for DragEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DragEvent, <DragEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Array`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Array, <Array as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<ScrollEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ScrollEvent ) -> Result<Reference, <Reference as TryFrom<ScrollEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for MouseOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<MouseOverEvent, <MouseOverEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Element> for SelectElement`[src]

`type Error = ConversionError`

`fn try_from( value: Element ) -> Result<SelectElement, <SelectElement as TryFrom<Element>>::Error>`[src]

`impl TryFrom<Reference> for TouchEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TouchEvent, <TouchEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for GotPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for ResourceAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ResourceAbortEvent, <ResourceAbortEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<HtmlElement> for TemplateElement`[src]

`type Error = ConversionError`

`fn try_from( value: HtmlElement ) -> Result<TemplateElement, <TemplateElement as TryFrom<HtmlElement>>::Error>`[src]

`impl TryFrom<Node> for InputElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<InputElement, <InputElement as TryFrom<Node>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TextNode`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TextNode, <TextNode as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for PointerLockChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerLockChangeEvent, <PointerLockChangeEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<BlurEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: BlurEvent ) -> Result<Reference, <Reference as TryFrom<BlurEvent>>::Error>`[src]

`impl TryFrom<Value> for PointerLockErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerLockErrorEvent, <PointerLockErrorEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<UiEvent> for GotPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Reference> for Touch`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Touch, <Touch as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for DragOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DragOverEvent, <DragOverEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TemplateElement`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TemplateElement, <TemplateElement as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for i32`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<i32, <i32 as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for HtmlCollection`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<HtmlCollection, <HtmlCollection as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<u16> for Value`[src]

`type Error = Void`

`fn try_from(source: u16) -> Result<Value, <Value as TryFrom<u16>>::Error>`[src]

`impl TryFrom<Reference> for Location`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Location, <Location as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Location`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Location, <Location as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<NotFoundError> for Reference`[src]

`type Error = Void`

`fn try_from( value: NotFoundError ) -> Result<Reference, <Reference as TryFrom<NotFoundError>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragDropEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragDropEvent, <DragDropEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for CanvasGradient`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<CanvasGradient, <CanvasGradient as TryFrom<Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragEnterEvent, <DragEnterEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<ResizeEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ResizeEvent ) -> Result<Reference, <Reference as TryFrom<ResizeEvent>>::Error>`[src]

`impl TryFrom<Reference> for FileReader`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<FileReader, <FileReader as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DragOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DragOverEvent, <DragOverEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for NotSupportedError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<NotSupportedError, <NotSupportedError as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PopStateEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PopStateEvent, <PopStateEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'a> TryFrom<&'a mut String> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a mut String ) -> Result<Value, <Value as TryFrom<&'a mut String>>::Error>`[src]

`impl TryFrom<PointerEvent> for LostPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<LostPointerCaptureEvent, <LostPointerCaptureEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for OptionElement`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<OptionElement, <OptionElement as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Window> for Reference`[src]

`type Error = Void`

`fn try_from( value: Window ) -> Result<Reference, <Reference as TryFrom<Window>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for FileList`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<FileList, <FileList as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for Option<f64>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<f64>, <Option<f64> as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerLockChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerLockChangeEvent, <PointerLockChangeEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Date`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Date, <Date as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for DataTransferItemList`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DataTransferItemList, <DataTransferItemList as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DragEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DragEnterEvent, <DragEnterEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for TouchMove`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TouchMove, <TouchMove as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for GamepadDisconnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<GamepadDisconnectedEvent, <GamepadDisconnectedEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for Document`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Document, <Document as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for FileList`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<FileList, <FileList as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<DomException> for InvalidCharacterError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<InvalidCharacterError, <InvalidCharacterError as TryFrom<DomException>>::Error>`[src]

`impl TryFrom<Value> for DragStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragStartEvent, <DragStartEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for ClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<ClickEvent, <ClickEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<HtmlElement> for Reference`[src]

`type Error = Void`

`fn try_from( value: HtmlElement ) -> Result<Reference, <Reference as TryFrom<HtmlElement>>::Error>`[src]

`impl TryFrom<usize> for Value`[src]

`type Error = <Number as TryFrom<usize>>::Error`

`fn try_from(value: usize) -> Result<Value, <Value as TryFrom<usize>>::Error>`[src]

`impl TryFrom<Reference> for DoubleClickEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DoubleClickEvent, <DoubleClickEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for DataTransferItem`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DataTransferItem, <DataTransferItem as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for ClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<ClickEvent, <ClickEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TypeError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TypeError, <TypeError as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SlotElement`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SlotElement, <SlotElement as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for EventTarget`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<EventTarget, <EventTarget as TryFrom<Reference>>::Error>`[src]

`impl<V> TryFrom<Value> for Option<BTreeMap<String, V>> where V: TryFrom<Value, Error = ConversionError>,` [src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<BTreeMap<String, V>>, <Option<BTreeMap<String, V>> as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TouchEnd`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TouchEnd, <TouchEnd as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Object`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Object, <Object as TryFrom<&'_r Value>>::Error>`[src]

`impl<K, V> TryFrom<HashMap<K, V, RandomState>> for Value where K: AsRef<str> + Eq + Hash, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: HashMap<K, V, RandomState> ) -> Result<Value, <Value as TryFrom<HashMap<K, V, RandomState>>>::Error>`[src]

`impl TryFrom<Error> for AbortError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<AbortError, <AbortError as TryFrom<Error>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for MutationObserver`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<MutationObserver, <MutationObserver as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for File`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<File, <File as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for MouseUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<MouseUpEvent, <MouseUpEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Event> for SocketOpenEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<SocketOpenEvent, <SocketOpenEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<PointerDownEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerDownEvent ) -> Result<Reference, <Reference as TryFrom<PointerDownEvent>>::Error>`[src]

`impl TryFrom<Value> for Gamepad`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Gamepad, <Gamepad as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for LoadEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<LoadEndEvent, <LoadEndEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Reference> for XmlHttpRequest`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<XmlHttpRequest, <XmlHttpRequest as TryFrom<Reference>>::Error>`[src]

`impl<'a> TryFrom<&'a String> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a String ) -> Result<Value, <Value as TryFrom<&'a String>>::Error>`[src]

`impl TryFrom<Event> for ContextMenuEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ContextMenuEvent, <ContextMenuEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Reference> for InputElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<InputElement, <InputElement as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Undefined> for Value`[src]

`type Error = Void`

`fn try_from( source: Undefined ) -> Result<Value, <Value as TryFrom<Undefined>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Error`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Error, <Error as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for u16`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<u16, <u16 as TryFrom<Value>>::Error>`[src]

`impl<'a, T> TryFrom<&'a Serde<T>> for Value where T: Serialize,` [src]

`type Error = ConversionError`

`fn try_from( value: &'a Serde<T> ) -> Result<Value, <Value as TryFrom<&'a Serde<T>>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragOverEvent, <DragOverEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl<'a> TryFrom<&'a mut str> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a mut str ) -> Result<Value, <Value as TryFrom<&'a mut str>>::Error>`[src]

`impl TryFrom<NamespaceError> for Reference`[src]

`type Error = Void`

`fn try_from( value: NamespaceError ) -> Result<Reference, <Reference as TryFrom<NamespaceError>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TouchStart`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TouchStart, <TouchStart as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for DragOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DragOverEvent, <DragOverEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for PointerLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<PointerLeaveEvent, <PointerLeaveEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerOutEvent, <PointerOutEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Event> for MouseOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<MouseOutEvent, <MouseOutEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Reference> for TouchCancel`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TouchCancel, <TouchCancel as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for Node`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Node, <Node as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for ProgressLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ProgressLoadEvent, <ProgressLoadEvent as TryFrom<Value>>::Error>`[src]

`impl<E, V> TryFrom<Array> for Vec<V> where E: Into<ConversionError>, V: TryFrom<Value, Error = E>,` [src]

`type Error = ConversionError`

`fn try_from(array: Array) -> Result<Vec<V>, <Vec<V> as TryFrom<Array>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for AbortError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<AbortError, <AbortError as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for IndexSizeError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<IndexSizeError, <IndexSizeError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for u8`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<u8, <u8 as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for PointerDownEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DomException`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DomException, <DomException as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<DomException> for IndexSizeError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<IndexSizeError, <IndexSizeError as TryFrom<DomException>>::Error>`[src]

`impl TryFrom<Number> for i8`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<i8, <i8 as TryFrom<Number>>::Error>`[src]

`impl TryFrom<Value> for TouchType`[src]

`type Error = ConversionError`

`fn try_from(v: Value) -> Result<TouchType, <TouchType as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Node> for OptionElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<OptionElement, <OptionElement as TryFrom<Node>>::Error>`[src]

`impl TryFrom<Reference> for AbortError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<AbortError, <AbortError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for Array`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Array, <Array as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for u32`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<u32, <u32 as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ReadyStateChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ReadyStateChangeEvent, <ReadyStateChangeEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for MouseOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<MouseOverEvent, <MouseOverEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerDownEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Number> for u16`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<u16, <u16 as TryFrom<Number>>::Error>`[src]

`impl TryFrom<TouchEvent> for TouchMove`[src]

`type Error = ConversionError`

`fn try_from( value: TouchEvent ) -> Result<TouchMove, <TouchMove as TryFrom<TouchEvent>>::Error>`[src]

`impl TryFrom<Value> for Option<u64>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<u64>, <Option<u64> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<NotSupportedError> for Reference`[src]

`type Error = Void`

`fn try_from( value: NotSupportedError ) -> Result<Reference, <Reference as TryFrom<NotSupportedError>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for AuxClickEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<AuxClickEvent, <AuxClickEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Number> for usize`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<usize, <usize as TryFrom<Number>>::Error>`[src]

`impl TryFrom<Error> for NotFoundError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<NotFoundError, <NotFoundError as TryFrom<Error>>::Error>`[src]

`impl TryFrom<Value> for Option<i8>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<i8>, <Option<i8> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for Selection`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Selection, <Selection as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for DragEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragEnterEvent, <DragEnterEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<EventTarget> for XmlHttpRequest`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<XmlHttpRequest, <XmlHttpRequest as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Value> for Symbol`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Symbol, <Symbol as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for TouchEnter`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TouchEnter, <TouchEnter as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for SocketCloseEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<SocketCloseEvent, <SocketCloseEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<NoModificationAllowedError> for Reference`[src]

`type Error = Void`

`fn try_from( value: NoModificationAllowedError ) -> Result<Reference, <Reference as TryFrom<NoModificationAllowedError>>::Error>`[src]

`impl TryFrom<Reference> for LostPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<LostPointerCaptureEvent, <LostPointerCaptureEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for BlurEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<BlurEvent, <BlurEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for SelectElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SelectElement, <SelectElement as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for MouseEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<MouseEnterEvent, <MouseEnterEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for BeforeUnloadEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<BeforeUnloadEvent, <BeforeUnloadEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for StringMap`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<StringMap, <StringMap as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<bool> for Value`[src]

`type Error = Void`

`fn try_from(source: bool) -> Result<Value, <Value as TryFrom<bool>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SubmitEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SubmitEvent, <SubmitEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for MutationRecord`[src]

`type Error = ConversionError`

`fn try_from( v: Value ) -> Result<MutationRecord, <MutationRecord as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TouchLeave`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TouchLeave, <TouchLeave as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for GamepadButton`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<GamepadButton, <GamepadButton as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for KeyUpEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<KeyUpEvent, <KeyUpEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<DragOverEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DragOverEvent ) -> Result<Reference, <Reference as TryFrom<DragOverEvent>>::Error>`[src]

`impl TryFrom<Reference> for TypeError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TypeError, <TypeError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<UiEvent> for PointerUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<PointerUpEvent, <PointerUpEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<StringMap> for Reference`[src]

`type Error = Void`

`fn try_from( value: StringMap ) -> Result<Reference, <Reference as TryFrom<StringMap>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for MouseOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<MouseOverEvent, <MouseOverEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Date`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Date, <Date as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Error> for Reference`[src]

`type Error = Void`

`fn try_from( value: Error ) -> Result<Reference, <Reference as TryFrom<Error>>::Error>`[src]

`impl<'a, T> TryFrom<&'a [T]> for Value where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a [T] ) -> Result<Value, <Value as TryFrom<&'a [T]>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TouchEnd`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TouchEnd, <TouchEnd as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for SocketOpenEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SocketOpenEvent, <SocketOpenEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<MouseOutEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseOutEvent ) -> Result<Reference, <Reference as TryFrom<MouseOutEvent>>::Error>`[src]

`impl TryFrom<Value> for Selection`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Selection, <Selection as TryFrom<Value>>::Error>`[src]

`impl TryFrom<TouchEvent> for TouchStart`[src]

`type Error = ConversionError`

`fn try_from( value: TouchEvent ) -> Result<TouchStart, <TouchStart as TryFrom<TouchEvent>>::Error>`[src]

`impl TryFrom<Event> for ScrollEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ScrollEvent, <ScrollEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for Array`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Array, <Array as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for KeyDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<KeyDownEvent, <KeyDownEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for InvalidCharacterError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<InvalidCharacterError, <InvalidCharacterError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for GamepadMappingType`[src]

`type Error = ConversionError`

`fn try_from( v: Value ) -> Result<GamepadMappingType, <GamepadMappingType as TryFrom<Value>>::Error>`[src]

`impl<'a, T> TryFrom<&'a mut [T]> for Array where T: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a mut [T] ) -> Result<Array, <Array as TryFrom<&'a mut [T]>>::Error>`[src]

`impl TryFrom<Event> for TouchEnd`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<TouchEnd, <TouchEnd as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for SlotElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SlotElement, <SlotElement as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for MouseEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<MouseEnterEvent, <MouseEnterEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SelectionChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SelectionChangeEvent, <SelectionChangeEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ResourceLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ResourceLoadEvent, <ResourceLoadEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DragEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DragEndEvent, <DragEndEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for Error`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Error, <Error as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DragLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DragLeaveEvent, <DragLeaveEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for PointerUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerUpEvent, <PointerUpEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StringMap`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<StringMap, <StringMap as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragEndEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragEndEvent, <DragEndEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<f32> for Value`[src]

`type Error = Void`

`fn try_from(source: f32) -> Result<Value, <Value as TryFrom<f32>>::Error>`[src]

`impl TryFrom<EventTarget> for InputElement`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<InputElement, <InputElement as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<ProgressRelatedEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ProgressRelatedEvent ) -> Result<Reference, <Reference as TryFrom<ProgressRelatedEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for KeyPressEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<KeyPressEvent, <KeyPressEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<UiEvent> for ResourceLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<ResourceLoadEvent, <ResourceLoadEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Reference> for HtmlCollection`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<HtmlCollection, <HtmlCollection as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for TouchEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<TouchEvent, <TouchEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for BlurEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<BlurEvent, <BlurEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'a> TryFrom<&'a Value> for &'a Reference`[src]

`type Error = ConversionError`

`fn try_from( value: &'a Value ) -> Result<&'a Reference, <&'a Reference as TryFrom<&'a Value>>::Error>`[src]

`impl TryFrom<Value> for Null`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Null, <Null as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for ScrollEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ScrollEvent, <ScrollEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for MouseUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<MouseUpEvent, <MouseUpEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<MouseEvent> for MouseWheelEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<MouseWheelEvent, <MouseWheelEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Event> for Reference`[src]

`type Error = Void`

`fn try_from( value: Event ) -> Result<Reference, <Reference as TryFrom<Event>>::Error>`[src]

`impl TryFrom<MouseEvent> for PointerOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<PointerOutEvent, <PointerOutEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Reference> for DragEndEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DragEndEvent, <DragEndEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for GamepadConnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<GamepadConnectedEvent, <GamepadConnectedEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<u8> for Value`[src]

`type Error = Void`

`fn try_from(source: u8) -> Result<Value, <Value as TryFrom<u8>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for XmlHttpRequest`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<XmlHttpRequest, <XmlHttpRequest as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for TouchEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TouchEvent, <TouchEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<SelectElement> for Reference`[src]

`type Error = Void`

`fn try_from( value: SelectElement ) -> Result<Reference, <Reference as TryFrom<SelectElement>>::Error>`[src]

`impl TryFrom<ResourceErrorEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ResourceErrorEvent ) -> Result<Reference, <Reference as TryFrom<ResourceErrorEvent>>::Error>`[src]

`impl TryFrom<MouseEvent> for GotPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Reference> for NotSupportedError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<NotSupportedError, <NotSupportedError as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for WebSocket`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<WebSocket, <WebSocket as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<FocusRelatedEvent> for BlurEvent`[src]

`type Error = ConversionError`

`fn try_from( value: FocusRelatedEvent ) -> Result<BlurEvent, <BlurEvent as TryFrom<FocusRelatedEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragEvent, <DragEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<PointerLeaveEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerLeaveEvent ) -> Result<Reference, <Reference as TryFrom<PointerLeaveEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SocketErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SocketErrorEvent, <SocketErrorEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for Option<u16>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<u16>, <Option<u16> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for ImageData`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ImageData, <ImageData as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for TemplateElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TemplateElement, <TemplateElement as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<PointerEvent> for PointerOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<PointerOverEvent, <PointerOverEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl TryFrom<Value> for ResizeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ResizeEvent, <ResizeEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for PointerCancelEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerCancelEvent, <PointerCancelEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<MouseEvent> for PointerLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<PointerLeaveEvent, <PointerLeaveEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Event> for TouchEnter`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<TouchEnter, <TouchEnter as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Value> for Option<i32>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<i32>, <Option<i32> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for DragLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DragLeaveEvent, <DragLeaveEvent as TryFrom<Event>>::Error>`[src]

`impl<'a> TryFrom<&'a char> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a char ) -> Result<Value, <Value as TryFrom<&'a char>>::Error>`[src]

`impl TryFrom<Element> for TemplateElement`[src]

`type Error = ConversionError`

`fn try_from( value: Element ) -> Result<TemplateElement, <TemplateElement as TryFrom<Element>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for NodeList`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<NodeList, <NodeList as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for OptionElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<OptionElement, <OptionElement as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ResourceAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ResourceAbortEvent, <ResourceAbortEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for Option<FormDataEntry>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<FormDataEntry>, <Option<FormDataEntry> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for SubmitEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SubmitEvent, <SubmitEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for History`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<History, <History as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<MouseEvent> for DoubleClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DoubleClickEvent, <DoubleClickEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TouchEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TouchEvent, <TouchEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<PointerEvent> for PointerLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<PointerLeaveEvent, <PointerLeaveEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl TryFrom<Value> for TokenList`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TokenList, <TokenList as TryFrom<Value>>::Error>`[src]

`impl TryFrom<DomException> for SecurityError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<SecurityError, <SecurityError as TryFrom<DomException>>::Error>`[src]

`impl TryFrom<Value> for HierarchyRequestError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<HierarchyRequestError, <HierarchyRequestError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for History`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<History, <History as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for NotFoundError`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<NotFoundError, <NotFoundError as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<EventTarget> for Element`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<Element, <Element as TryFrom<EventTarget>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Location`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Location, <Location as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for MouseEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<MouseEnterEvent, <MouseEnterEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<HtmlElement> for TextAreaElement`[src]

`type Error = ConversionError`

`fn try_from( value: HtmlElement ) -> Result<TextAreaElement, <TextAreaElement as TryFrom<HtmlElement>>::Error>`[src]

`impl TryFrom<Value> for OptionElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<OptionElement, <OptionElement as TryFrom<Value>>::Error>`[src]

`impl TryFrom<ReadyStateChangeEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: ReadyStateChangeEvent ) -> Result<Reference, <Reference as TryFrom<ReadyStateChangeEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ChangeEvent, <ChangeEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TemplateElement`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TemplateElement, <TemplateElement as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for TokenList`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<TokenList, <TokenList as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<DataTransferItem> for Reference`[src]

`type Error = Void`

`fn try_from( value: DataTransferItem ) -> Result<Reference, <Reference as TryFrom<DataTransferItem>>::Error>`[src]

`impl TryFrom<Value> for MouseUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<MouseUpEvent, <MouseUpEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for Date`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Date, <Date as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragRelatedEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragRelatedEvent, <DragRelatedEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<EventTarget> for ShadowRoot`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<ShadowRoot, <ShadowRoot as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Event> for PointerMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<PointerMoveEvent, <PointerMoveEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<DomException> for NotSupportedError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<NotSupportedError, <NotSupportedError as TryFrom<DomException>>::Error>`[src]

`impl TryFrom<Value> for KeyUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<KeyUpEvent, <KeyUpEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<ArrayBuffer> for Reference`[src]

`type Error = Void`

`fn try_from( value: ArrayBuffer ) -> Result<Reference, <Reference as TryFrom<ArrayBuffer>>::Error>`[src]

`impl TryFrom<Error> for DomException`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<DomException, <DomException as TryFrom<Error>>::Error>`[src]

`impl TryFrom<Element> for CanvasElement`[src]

`type Error = ConversionError`

`fn try_from( value: Element ) -> Result<CanvasElement, <CanvasElement as TryFrom<Element>>::Error>`[src]

`impl TryFrom<Null> for Value`[src]

`type Error = Void`

`fn try_from(source: Null) -> Result<Value, <Value as TryFrom<Null>>::Error>`[src]

`impl TryFrom<Value> for Option<i64>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<i64>, <Option<i64> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for Element`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Element, <Element as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for InvalidAccessError`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<InvalidAccessError, <InvalidAccessError as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for Option<usize>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<usize>, <Option<usize> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for GamepadConnectedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<GamepadConnectedEvent, <GamepadConnectedEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<DragExitEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DragExitEvent ) -> Result<Reference, <Reference as TryFrom<DragExitEvent>>::Error>`[src]

`impl<E, V> TryFrom<Value> for HashMap<String, V, RandomState> where E: Into<ConversionError>, V: TryFrom<Value, Error = E>,` [src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<HashMap<String, V, RandomState>, <HashMap<String, V, RandomState> as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DataTransferItem`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DataTransferItem, <DataTransferItem as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<FocusRelatedEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: FocusRelatedEvent ) -> Result<Reference, <Reference as TryFrom<FocusRelatedEvent>>::Error>`[src]

`impl TryFrom<Error> for HierarchyRequestError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<HierarchyRequestError, <HierarchyRequestError as TryFrom<Error>>::Error>`[src]

`impl TryFrom<EventTarget> for CanvasElement`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<CanvasElement, <CanvasElement as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Value> for ProgressAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ProgressAbortEvent, <ProgressAbortEvent as TryFrom<Value>>::Error>`[src]

`impl<'de, T> TryFrom<Value> for Serde<T> where T: Deserialize<'de>,` [src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Serde<T>, <Serde<T> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for LoadStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<LoadStartEvent, <LoadStartEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for GotPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerMoveEvent, <PointerMoveEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for FileReader`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<FileReader, <FileReader as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for MouseOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<MouseOutEvent, <MouseOutEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Node> for ImageElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<ImageElement, <ImageElement as TryFrom<Node>>::Error>`[src]

`impl TryFrom<UiEvent> for DragLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DragLeaveEvent, <DragLeaveEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<T> TryFrom<Value> for TypedArray<T> where T: ArrayKind,` [src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<TypedArray<T>, <TypedArray<T> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for Blob`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<Blob, <Blob as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<AbortError> for Reference`[src]

`type Error = Void`

`fn try_from( value: AbortError ) -> Result<Reference, <Reference as TryFrom<AbortError>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for HierarchyRequestError`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<HierarchyRequestError, <HierarchyRequestError as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<PointerMoveEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerMoveEvent ) -> Result<Reference, <Reference as TryFrom<PointerMoveEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Object`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Object, <Object as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Array`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Array, <Array as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for LostPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<LostPointerCaptureEvent, <LostPointerCaptureEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<InvalidStateError> for Reference`[src]

`type Error = Void`

`fn try_from( value: InvalidStateError ) -> Result<Reference, <Reference as TryFrom<InvalidStateError>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for MouseOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<MouseOutEvent, <MouseOutEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ScrollEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ScrollEvent, <ScrollEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<i8> for Number`[src]

`type Error = Void`

`fn try_from(value: i8) -> Result<Number, <Number as TryFrom<i8>>::Error>`[src]

`impl TryFrom<Reference> for WebSocket`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<WebSocket, <WebSocket as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for DragDropEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DragDropEvent, <DragDropEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Event> for ResizeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ResizeEvent, <ResizeEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<Reference> for PointerLockErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<PointerLockErrorEvent, <PointerLockErrorEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SubmitEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SubmitEvent, <SubmitEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for i64`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<i64, <i64 as TryFrom<Value>>::Error>`[src]

`impl TryFrom<EventTarget> for Window`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<Window, <Window as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Event> for ProgressLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<ProgressLoadEvent, <ProgressLoadEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Window`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Window, <Window as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Node> for HtmlElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<HtmlElement, <HtmlElement as TryFrom<Node>>::Error>`[src]

`impl TryFrom<Value> for DoubleClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DoubleClickEvent, <DoubleClickEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for ArrayBuffer`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ArrayBuffer, <ArrayBuffer as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for MutationObserver`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<MutationObserver, <MutationObserver as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragOverEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragOverEvent, <DragOverEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<DomException> for AbortError`[src]

`type Error = ConversionError`

`fn try_from( value: DomException ) -> Result<AbortError, <AbortError as TryFrom<DomException>>::Error>`[src]

`impl TryFrom<Event> for InputEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<InputEvent, <InputEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<GamepadDisconnectedEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: GamepadDisconnectedEvent ) -> Result<Reference, <Reference as TryFrom<GamepadDisconnectedEvent>>::Error>`[src]

`impl TryFrom<Reference> for ProgressLoadEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ProgressLoadEvent, <ProgressLoadEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Reference> for ChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ChangeEvent, <ChangeEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for i8`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<i8, <i8 as TryFrom<Value>>::Error>`[src]

`impl TryFrom<PointerLockChangeEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: PointerLockChangeEvent ) -> Result<Reference, <Reference as TryFrom<PointerLockChangeEvent>>::Error>`[src]

`impl TryFrom<Range> for Reference`[src]

`type Error = Void`

`fn try_from( value: Range ) -> Result<Reference, <Reference as TryFrom<Range>>::Error>`[src]

`impl TryFrom<Value> for DataTransfer`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DataTransfer, <DataTransfer as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for SecurityError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<SecurityError, <SecurityError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for Location`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Location, <Location as TryFrom<Value>>::Error>`[src]

`impl<'a> TryFrom<&'a Null> for Value`[src]

`type Error = Void`

`fn try_from( source: &'a Null ) -> Result<Value, <Value as TryFrom<&'a Null>>::Error>`[src]

`impl TryFrom<Event> for KeyUpEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<KeyUpEvent, <KeyUpEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<TemplateElement> for Reference`[src]

`type Error = Void`

`fn try_from( value: TemplateElement ) -> Result<Reference, <Reference as TryFrom<TemplateElement>>::Error>`[src]

`impl TryFrom<MouseEvent> for MouseDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<MouseDownEvent, <MouseDownEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<KeyDownEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: KeyDownEvent ) -> Result<Reference, <Reference as TryFrom<KeyDownEvent>>::Error>`[src]

`impl<'a, K, V> TryFrom<&'a BTreeMap<K, V>> for Object where K: AsRef<str>, V: JsSerialize,` [src]

`type Error = Void`

`fn try_from( source: &'a BTreeMap<K, V> ) -> Result<Object, <Object as TryFrom<&'a BTreeMap<K, V>>>::Error>`[src]

`impl TryFrom<FocusEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: FocusEvent ) -> Result<Reference, <Reference as TryFrom<FocusEvent>>::Error>`[src]

`impl TryFrom<Value> for ArrayBuffer`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ArrayBuffer, <ArrayBuffer as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for HtmlElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<HtmlElement, <HtmlElement as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TouchStart`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TouchStart, <TouchStart as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<DataTransferItemList> for Reference`[src]

`type Error = Void`

`fn try_from( value: DataTransferItemList ) -> Result<Reference, <Reference as TryFrom<DataTransferItemList>>::Error>`[src]

`impl TryFrom<Value> for KeyPressEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<KeyPressEvent, <KeyPressEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Rect> for Reference`[src]

`type Error = Void`

`fn try_from( value: Rect ) -> Result<Reference, <Reference as TryFrom<Rect>>::Error>`[src]

`impl TryFrom<Reference> for DataTransferItemList`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<DataTransferItemList, <DataTransferItemList as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for CanvasStyle`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<CanvasStyle, <CanvasStyle as TryFrom<Value>>::Error>`[src]

Performs the conversion.

`impl TryFrom<UiEvent> for PointerMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<PointerMoveEvent, <PointerMoveEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DataTransferItemList`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DataTransferItemList, <DataTransferItemList as TryFrom<&'_r Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerLeaveEvent, <PointerLeaveEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Event> for FocusEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<FocusEvent, <FocusEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for InputElement`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<InputElement, <InputElement as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for DragExitEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragExitEvent, <DragExitEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragEnterEvent, <DragEnterEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SocketOpenEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SocketOpenEvent, <SocketOpenEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<HtmlElement> for OptionElement`[src]

`type Error = ConversionError`

`fn try_from( value: HtmlElement ) -> Result<OptionElement, <OptionElement as TryFrom<HtmlElement>>::Error>`[src]

`impl TryFrom<DragRelatedEvent> for DragStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: DragRelatedEvent ) -> Result<DragStartEvent, <DragStartEvent as TryFrom<DragRelatedEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DragDropEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DragDropEvent, <DragDropEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Reference> for BlurEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<BlurEvent, <BlurEvent as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for InputEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<InputEvent, <InputEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<SyntaxError> for Reference`[src]

`type Error = Void`

`fn try_from( value: SyntaxError ) -> Result<Reference, <Reference as TryFrom<SyntaxError>>::Error>`[src]

`impl TryFrom<GamepadButton> for Reference`[src]

`type Error = Void`

`fn try_from( value: GamepadButton ) -> Result<Reference, <Reference as TryFrom<GamepadButton>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for TokenList`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<TokenList, <TokenList as TryFrom<&'_r Value>>::Error>`[src]

`impl<'a> TryFrom<&'a Value> for Option<&'a str>`[src]

`type Error = ConversionError`

`fn try_from( value: &'a Value ) -> Result<Option<&'a str>, <Option<&'a str> as TryFrom<&'a Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DoubleClickEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DoubleClickEvent, <DoubleClickEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for SelectElement`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<SelectElement, <SelectElement as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<InvalidCharacterError> for Reference`[src]

`type Error = Void`

`fn try_from( value: InvalidCharacterError ) -> Result<Reference, <Reference as TryFrom<InvalidCharacterError>>::Error>`[src]

`impl TryFrom<ProgressRelatedEvent> for ProgressAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( value: ProgressRelatedEvent ) -> Result<ProgressAbortEvent, <ProgressAbortEvent as TryFrom<ProgressRelatedEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PointerOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<PointerOverEvent, <PointerOverEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Event> for DragRelatedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<DragRelatedEvent, <DragRelatedEvent as TryFrom<Event>>::Error>`[src]

`impl TryFrom<u64> for Value`[src]

`type Error = <Number as TryFrom<u64>>::Error`

`fn try_from(value: u64) -> Result<Value, <Value as TryFrom<u64>>::Error>`[src]

`impl TryFrom<Value> for ContextMenuEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<ContextMenuEvent, <ContextMenuEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<UiEvent> for DragEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DragEnterEvent, <DragEnterEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for DragStartEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DragStartEvent, <DragStartEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for MouseOutEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<MouseOutEvent, <MouseOutEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<MouseWheelEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseWheelEvent ) -> Result<Reference, <Reference as TryFrom<MouseWheelEvent>>::Error>`[src]

`impl TryFrom<UiEvent> for DragExitEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DragExitEvent, <DragExitEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for AuxClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<AuxClickEvent, <AuxClickEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<FileList> for Reference`[src]

`type Error = Void`

`fn try_from( value: FileList ) -> Result<Reference, <Reference as TryFrom<FileList>>::Error>`[src]

`impl TryFrom<Error> for InvalidCharacterError`[src]

`type Error = ConversionError`

`fn try_from( value: Error ) -> Result<InvalidCharacterError, <InvalidCharacterError as TryFrom<Error>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for MouseDownEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<MouseDownEvent, <MouseDownEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<MouseEvent> for AuxClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<AuxClickEvent, <AuxClickEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<EventTarget> for SelectElement`[src]

`type Error = ConversionError`

`fn try_from( value: EventTarget ) -> Result<SelectElement, <SelectElement as TryFrom<EventTarget>>::Error>`[src]

`impl TryFrom<Value> for HtmlElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<HtmlElement, <HtmlElement as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Storage`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<Storage, <Storage as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Node> for SlotElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<SlotElement, <SlotElement as TryFrom<Node>>::Error>`[src]

`impl TryFrom<Number> for i32`[src]

`type Error = ConversionError`

`fn try_from(number: Number) -> Result<i32, <i32 as TryFrom<Number>>::Error>`[src]

`impl TryFrom<ImageData> for Reference`[src]

`type Error = Void`

`fn try_from( value: ImageData ) -> Result<Reference, <Reference as TryFrom<ImageData>>::Error>`[src]

`impl TryFrom<UiEvent> for DoubleClickEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<DoubleClickEvent, <DoubleClickEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<Value> for Option<u32>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<u32>, <Option<u32> as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for DragEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<DragEvent, <DragEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<UiEvent> for PointerOverEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<PointerOverEvent, <PointerOverEvent as TryFrom<UiEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PointerOutEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<PointerOutEvent, <PointerOutEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for FocusEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<FocusEvent, <FocusEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<Value> for MouseOutEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<MouseOutEvent, <MouseOutEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<DoubleClickEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: DoubleClickEvent ) -> Result<Reference, <Reference as TryFrom<DoubleClickEvent>>::Error>`[src]

`impl TryFrom<GamepadEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: GamepadEvent ) -> Result<Reference, <Reference as TryFrom<GamepadEvent>>::Error>`[src]

`impl TryFrom<Value> for PointerEnterEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerEnterEvent, <PointerEnterEvent as TryFrom<Value>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for MouseLeaveEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<MouseLeaveEvent, <MouseLeaveEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ProgressErrorEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<ProgressErrorEvent, <ProgressErrorEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Value> for FileReader`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<FileReader, <FileReader as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Event> for MouseDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Event ) -> Result<MouseDownEvent, <MouseDownEvent as TryFrom<Event>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ArrayBuffer`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ArrayBuffer, <ArrayBuffer as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<Value> for DrawImageError`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DrawImageError, <DrawImageError as TryFrom<Value>>::Error>`[src]

`impl TryFrom<HtmlCollection> for Reference`[src]

`type Error = Void`

`fn try_from( value: HtmlCollection ) -> Result<Reference, <Reference as TryFrom<HtmlCollection>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragDropEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragDropEvent, <DragDropEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl<T> TryFrom<Reference> for TypedArray<T> where T: ArrayKind,` [src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<TypedArray<T>, <TypedArray<T> as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<usize> for Number`[src]

`type Error = ConversionError`

`fn try_from(value: usize) -> Result<Number, <Number as TryFrom<usize>>::Error>`[src]

`impl TryFrom<Reference> for ProgressAbortEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ProgressAbortEvent, <ProgressAbortEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<PointerEvent> for GotPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( value: PointerEvent ) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<PointerEvent>>::Error>`[src]

`impl TryFrom<InvalidPointerId> for Reference`[src]

`type Error = Void`

`fn try_from( value: InvalidPointerId ) -> Result<Reference, <Reference as TryFrom<InvalidPointerId>>::Error>`[src]

`impl TryFrom<HeapStatistics> for Value`

`type Error = ConversionError`

`fn try_from(value: HeapStatistics) -> Result<Self, Self::Error>`

`impl<'_a> TryFrom<&'_a HeapStatistics> for Value`

`type Error = ConversionError`

`fn try_from(value: &'_a HeapStatistics) -> Result<Self, Self::Error>`

`impl<'_a> TryFrom<&'_a mut HeapStatistics> for Value`

`type Error = ConversionError`

`fn try_from(value: &'_a mut HeapStatistics) -> Result<Self, Self::Error>`

`impl<T> TryFrom<JsVec<T>> for Array`[src]

`type Error = ConversionError`

`fn try_from(jsv: JsVec<T>) -> Result<Array, Self::Error>`[src]

`impl<T> TryFrom<JsVec<T>> for Reference`[src]

`type Error = ConversionError`

`fn try_from(jsv: JsVec<T>) -> Result<Reference, Self::Error>`[src]

`impl TryFrom<RoomName> for Value`

`type Error = ConversionError`

`fn try_from(value: RoomName) -> Result<Self, Self::Error>`

`impl<'_a> TryFrom<&'_a RoomName> for Value`

`type Error = ConversionError`

`fn try_from(value: &'_a RoomName) -> Result<Self, Self::Error>`

`impl<'_a> TryFrom<&'_a mut RoomName> for Value`

`type Error = ConversionError`

`fn try_from(value: &'_a mut RoomName) -> Result<Self, Self::Error>`

`impl TryFrom<Position> for Value`

`type Error = ConversionError`

`fn try_from(value: Position) -> Result<Self, Self::Error>`

`impl<'_a> TryFrom<&'_a Position> for Value`

`type Error = ConversionError`

`fn try_from(value: &'_a Position) -> Result<Self, Self::Error>`

`impl<'_a> TryFrom<&'_a mut Position> for Value`

`type Error = ConversionError`

`fn try_from(value: &'_a mut Position) -> Result<Self, Self::Error>`

`impl TryFrom<Step> for Value`

`type Error = ConversionError`

`fn try_from(value: Step) -> Result<Self, Self::Error>`

`impl<'_a> TryFrom<&'_a Step> for Value`

`type Error = ConversionError`

`fn try_from(value: &'_a Step) -> Result<Self, Self::Error>`

`impl<'_a> TryFrom<&'_a mut Step> for Value`

`type Error = ConversionError`

`fn try_from(value: &'_a mut Step) -> Result<Self, Self::Error>`

`impl TryFrom<ConstructionSite> for Reference`[src]

`type Error = Void`

`fn try_from(value: ConstructionSite) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Creep> for Reference`[src]

`type Error = Void`

`fn try_from(value: Creep) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Flag> for Reference`[src]

`type Error = Void`

`fn try_from(value: Flag) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Mineral> for Reference`[src]

`type Error = Void`

`fn try_from(value: Mineral) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Nuke> for Reference`[src]

`type Error = Void`

`fn try_from(value: Nuke) -> Result<Self, Self::Error>`[src]

`impl TryFrom<OwnedStructure> for Reference`[src]

`type Error = Void`

`fn try_from(value: OwnedStructure) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Resource> for Reference`[src]

`type Error = Void`

`fn try_from(value: Resource) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Room> for Reference`[src]

`type Error = Void`

`fn try_from(value: Room) -> Result<Self, Self::Error>`[src]

`impl TryFrom<RoomObject> for Reference`[src]

`type Error = Void`

`fn try_from(value: RoomObject) -> Result<Self, Self::Error>`[src]

`impl TryFrom<RoomTerrain> for Reference`[src]

`type Error = Void`

`fn try_from(value: RoomTerrain) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Source> for Reference`[src]

`type Error = Void`

`fn try_from(value: Source) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureContainer> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureContainer) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureController> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureController) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureExtension> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureExtension) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureExtractor> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureExtractor) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureKeeperLair> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureKeeperLair) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureLab> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureLab) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureLink> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureLink) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureNuker> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureNuker) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureObserver> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureObserver) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructurePowerBank> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructurePowerBank) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructurePowerSpawn> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructurePowerSpawn) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructurePortal> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructurePortal) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureRampart> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureRampart) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureRoad> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureRoad) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureSpawn> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureSpawn) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Spawning> for Reference`[src]

`type Error = Void`

`fn try_from(value: Spawning) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureStorage> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureStorage) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureTerminal> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureTerminal) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureTower> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureTower) -> Result<Self, Self::Error>`[src]

`impl TryFrom<StructureWall> for Reference`[src]

`type Error = Void`

`fn try_from(value: StructureWall) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Tombstone> for Reference`[src]

`type Error = Void`

`fn try_from(value: Tombstone) -> Result<Self, Self::Error>`[src]

`impl TryFrom<PowerCreep> for Reference`[src]

`type Error = Void`

`fn try_from(value: PowerCreep) -> Result<Self, Self::Error>`[src]

Loading content...

Implementors

`impl TryFrom<Value> for ReturnCode`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Direction`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Color`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Terrain`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Part`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for StructureType`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Density`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for ResourceType`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for PowerType`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for HeapStatistics`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for RoomRouteStep`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Player`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for TransactionOrder`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Transaction`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Order`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for MyOrder`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for RoomName`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Position`[src]

`type Error = <Value as TryInto<String>>::Error`

`fn try_from(v: Value) -> Result<Position, Self::Error>`[src]

`impl TryFrom<Value> for MemoryReference`[src]

`type Error = ConversionError`

`fn try_from(v: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Step`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for Path`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Value> for LookResult`[src]

`type Error = ConversionError`

`fn try_from(v: Value) -> Result<LookResult, Self::Error>`[src]

`impl TryFrom<Value> for PositionedLookResult`[src]

`type Error = ConversionError`

`fn try_from(v: Value) -> Result<PositionedLookResult, Self::Error>`[src]

`impl TryFrom<Value> for Structure`[src]

`type Error = ConversionError`

`fn try_from(v: Value) -> Result<Structure, Self::Error>`[src]

`impl TryFrom<Value> for ConstructionSite`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Creep`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Flag`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Mineral`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Nuke`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for OwnedStructure`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Resource`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Room`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for RoomObject`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for RoomTerrain`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Source`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureContainer`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureController`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureExtension`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureExtractor`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureKeeperLair`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureLab`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureLink`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureNuker`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureObserver`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructurePowerBank`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructurePowerSpawn`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructurePortal`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureRampart`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureRoad`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureSpawn`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Spawning`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureStorage`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureTerminal`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureTower`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for StructureWall`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for Tombstone`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for PowerCreep`[src]

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Value> for ForeignSegment`

`type Error = ConversionError`

`fn try_from(value: Value) -> Result<Self, Self::Error>`

`impl TryFrom<Reference> for Structure`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, ConversionError>`[src]

`impl TryFrom<Reference> for ConstructionSite`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for Creep`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for Flag`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for Mineral`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for Nuke`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for OwnedStructure`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for Resource`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for Room`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for RoomObject`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for RoomTerrain`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for Source`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureContainer`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureController`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureExtension`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureExtractor`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureKeeperLair`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureLab`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureLink`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureNuker`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureObserver`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructurePowerBank`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructurePowerSpawn`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructurePortal`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureRampart`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureRoad`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureSpawn`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for Spawning`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureStorage`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureTerminal`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureTower`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for StructureWall`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for Tombstone`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl TryFrom<Reference> for PowerCreep`[src]

`type Error = ConversionError`

`fn try_from(reference: Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ConstructionSite`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Creep`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Flag`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Mineral`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Nuke`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for OwnedStructure`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Resource`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Room`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for RoomObject`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for RoomTerrain`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Source`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureContainer`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureController`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureExtension`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureExtractor`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureKeeperLair`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureLab`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureLink`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureNuker`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureObserver`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructurePowerBank`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructurePowerSpawn`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructurePortal`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureRampart`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureRoad`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureSpawn`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Spawning`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureStorage`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureTerminal`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureTower`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for StructureWall`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Tombstone`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for PowerCreep`[src]

`type Error = ConversionError`

`fn try_from(value: &Value) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for ConstructionSite`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Creep`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Flag`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Mineral`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Nuke`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for OwnedStructure`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Resource`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Room`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for RoomObject`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for RoomTerrain`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Source`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureContainer`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureController`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureExtension`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureExtractor`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureKeeperLair`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureLab`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureLink`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureNuker`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureObserver`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructurePowerBank`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructurePowerSpawn`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructurePortal`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureRampart`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureRoad`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureSpawn`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Spawning`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureStorage`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureTerminal`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureTower`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for StructureWall`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for Tombstone`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for PowerCreep`[src]

`type Error = ConversionError`

`fn try_from(reference: &Reference) -> Result<Self, Self::Error>`[src]

`impl<T> TryFrom<Value> for JsVec<T> where T: InstanceOf,` [src]

`type Error = ConversionError`

`fn try_from(r: Value) -> Result<JsVec<T>, Self::Error>`[src]

`impl<T> TryFrom<Array> for JsVec<T> where T: InstanceOf,` [src]

`type Error = ConversionError`

`fn try_from(arr: Array) -> Result<JsVec<T>, Self::Error>`[src]

`impl<T> TryFrom<Reference> for JsVec<T> where T: InstanceOf,` [src]

`type Error = ConversionError`

`fn try_from(r: Reference) -> Result<JsVec<T>, Self::Error>`[src]

Loading content...

[−][src]Trait screeps::traits::TryFrom

Associated Types

type Error

Required methods

fn try_from(T) -> Result<Self, Self::Error>

Implementations on Foreign Types

impl<'_r> TryFrom<&'_r Reference> for EventTarget[src]

type Error = ConversionError

fn try_from( reference: &Reference) -> Result<EventTarget, <EventTarget as TryFrom<&'_r Reference>>::Error>[src]

impl TryFrom<TouchLeave> for Reference[src]

type Error = Void

fn try_from( value: TouchLeave) -> Result<Reference, <Reference as TryFrom<TouchLeave>>::Error>[src]

impl<'_r> TryFrom<&'_r Reference> for DragStartEvent[src]

type Error = ConversionError

fn try_from( reference: &Reference) -> Result<DragStartEvent, <DragStartEvent as TryFrom<&'_r Reference>>::Error>[src]

impl TryFrom<Reference> for GotPointerCaptureEvent[src]

type Error = ConversionError

fn try_from( reference: Reference) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<Reference>>::Error>[src]

impl TryFrom<MutationObserver> for Reference[src]

type Error = Void

fn try_from( value: MutationObserver) -> Result<Reference, <Reference as TryFrom<MutationObserver>>::Error>[src]

impl TryFrom<Value> for Option<i16>[src]

type Error = ConversionError

fn try_from( value: Value) -> Result<Option<i16>, <Option<i16> as TryFrom<Value>>::Error>[src]

impl TryFrom<Reference> for ImageElement[src]

type Error = ConversionError

fn try_from( reference: Reference) -> Result<ImageElement, <ImageElement as TryFrom<Reference>>::Error>[src]

impl TryFrom<SecurityError> for Reference[src]

type Error = Void

fn try_from( value: SecurityError) -> Result<Reference, <Reference as TryFrom<SecurityError>>::Error>[src]

impl TryFrom<Value> for InputElement[src]

type Error = ConversionError

fn try_from( value: Value) -> Result<InputElement, <InputElement as TryFrom<Value>>::Error>[src]

impl TryFrom<Reference> for GamepadButton[src]

type Error = ConversionError

fn try_from( reference: Reference) -> Result<GamepadButton, <GamepadButton as TryFrom<Reference>>::Error>[src]

impl<'_r> TryFrom<&'_r Value> for ShadowRoot[src]

type Error = ConversionError

fn try_from( value: &Value) -> Result<ShadowRoot, <ShadowRoot as TryFrom<&'_r Value>>::Error>[src]

impl TryFrom<KeyUpEvent> for Reference[src]

type Error = Void

fn try_from( value: KeyUpEvent) -> Result<Reference, <Reference as TryFrom<KeyUpEvent>>::Error>[src]

impl<'_r> TryFrom<&'_r Reference> for XmlHttpRequest[src]

type Error = ConversionError

fn try_from( reference: &Reference) -> Result<XmlHttpRequest, <XmlHttpRequest as TryFrom<&'_r Reference>>::Error>[src]

impl<'_r> TryFrom<&'_r Value> for SlotChangeEvent[src]

type Error = ConversionError

fn try_from( value: &Value) -> Result<SlotChangeEvent, <SlotChangeEvent as TryFrom<&'_r Value>>::Error>[src]

impl TryFrom<MouseEvent> for DragRelatedEvent[src]

type Error = ConversionError

fn try_from( value: MouseEvent) -> Result<DragRelatedEvent, <DragRelatedEvent as TryFrom<MouseEvent>>::Error>[src]

impl TryFrom<Node> for TemplateElement[src]

type Error = ConversionError

fn try_from( value: Node) -> Result<TemplateElement, <TemplateElement as TryFrom<Node>>::Error>[src]

impl<'_r> TryFrom<&'_r Value> for Error[src]

type Error = ConversionError

fn try_from( value: &Value) -> Result<Error, <Error as TryFrom<&'_r Value>>::Error>[src]

impl<T> TryFrom<TypedArray<T>> for Reference where T: ArrayKind, [src]

type Error = Void

fn try_from( value: TypedArray<T>) -> Result<Reference, <Reference as TryFrom<TypedArray<T>>>::Error>[src]

impl TryFrom<MouseEnterEvent> for Reference[src]

type Error = Void

fn try_from( value: MouseEnterEvent) -> Result<Reference, <Reference as TryFrom<MouseEnterEvent>>::Error>[src]

impl<'_r> TryFrom<&'_r Reference> for FormData[src]

type Error = ConversionError

fn try_from( reference: &Reference) -> Result<FormData, <FormData as TryFrom<&'_r Reference>>::Error>[src]

impl<'_r> TryFrom<&'_r Value> for GamepadButton[src]

type Error = ConversionError

fn try_from( value: &Value) -> Result<GamepadButton, <GamepadButton as TryFrom<&'_r Value>>::Error>[src]

impl TryFrom<UiEvent> for PointerDownEvent[src]

type Error = ConversionError

fn try_from( value: UiEvent) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<UiEvent>>::Error>[src]

impl TryFrom<HtmlElement> for CanvasElement[src]

type Error = ConversionError

fn try_from( value: HtmlElement) -> Result<CanvasElement, <CanvasElement as TryFrom<HtmlElement>>::Error>[src]

impl TryFrom<File> for Reference[src]

type Error = Void

fn try_from( value: File) -> Result<Reference, <Reference as TryFrom<File>>::Error>[src]

impl TryFrom<Value> for DragEvent[src]

type Error = ConversionError

`type Error`

`fn try_from(T) -> Result<Self, Self::Error>`

`impl<'_r> TryFrom<&'_r Reference> for EventTarget`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<EventTarget, <EventTarget as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<TouchLeave> for Reference`[src]

`type Error = Void`

`fn try_from( value: TouchLeave ) -> Result<Reference, <Reference as TryFrom<TouchLeave>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for DragStartEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<DragStartEvent, <DragStartEvent as TryFrom<&'_r Reference>>::Error>`[src]

`impl TryFrom<Reference> for GotPointerCaptureEvent`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<GotPointerCaptureEvent, <GotPointerCaptureEvent as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<MutationObserver> for Reference`[src]

`type Error = Void`

`fn try_from( value: MutationObserver ) -> Result<Reference, <Reference as TryFrom<MutationObserver>>::Error>`[src]

`impl TryFrom<Value> for Option<i16>`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<Option<i16>, <Option<i16> as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for ImageElement`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<ImageElement, <ImageElement as TryFrom<Reference>>::Error>`[src]

`impl TryFrom<SecurityError> for Reference`[src]

`type Error = Void`

`fn try_from( value: SecurityError ) -> Result<Reference, <Reference as TryFrom<SecurityError>>::Error>`[src]

`impl TryFrom<Value> for InputElement`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<InputElement, <InputElement as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Reference> for GamepadButton`[src]

`type Error = ConversionError`

`fn try_from( reference: Reference ) -> Result<GamepadButton, <GamepadButton as TryFrom<Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for ShadowRoot`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<ShadowRoot, <ShadowRoot as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<KeyUpEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: KeyUpEvent ) -> Result<Reference, <Reference as TryFrom<KeyUpEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for XmlHttpRequest`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<XmlHttpRequest, <XmlHttpRequest as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for SlotChangeEvent`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<SlotChangeEvent, <SlotChangeEvent as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<MouseEvent> for DragRelatedEvent`[src]

`type Error = ConversionError`

`fn try_from( value: MouseEvent ) -> Result<DragRelatedEvent, <DragRelatedEvent as TryFrom<MouseEvent>>::Error>`[src]

`impl TryFrom<Node> for TemplateElement`[src]

`type Error = ConversionError`

`fn try_from( value: Node ) -> Result<TemplateElement, <TemplateElement as TryFrom<Node>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for Error`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<Error, <Error as TryFrom<&'_r Value>>::Error>`[src]

`impl<T> TryFrom<TypedArray<T>> for Reference where T: ArrayKind,` [src]

`type Error = Void`

`fn try_from( value: TypedArray<T> ) -> Result<Reference, <Reference as TryFrom<TypedArray<T>>>::Error>`[src]

`impl TryFrom<MouseEnterEvent> for Reference`[src]

`type Error = Void`

`fn try_from( value: MouseEnterEvent ) -> Result<Reference, <Reference as TryFrom<MouseEnterEvent>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Reference> for FormData`[src]

`type Error = ConversionError`

`fn try_from( reference: &Reference ) -> Result<FormData, <FormData as TryFrom<&'_r Reference>>::Error>`[src]

`impl<'_r> TryFrom<&'_r Value> for GamepadButton`[src]

`type Error = ConversionError`

`fn try_from( value: &Value ) -> Result<GamepadButton, <GamepadButton as TryFrom<&'_r Value>>::Error>`[src]

`impl TryFrom<UiEvent> for PointerDownEvent`[src]

`type Error = ConversionError`

`fn try_from( value: UiEvent ) -> Result<PointerDownEvent, <PointerDownEvent as TryFrom<UiEvent>>::Error>`[src]

`impl TryFrom<HtmlElement> for CanvasElement`[src]

`type Error = ConversionError`

`fn try_from( value: HtmlElement ) -> Result<CanvasElement, <CanvasElement as TryFrom<HtmlElement>>::Error>`[src]

`impl TryFrom<File> for Reference`[src]

`type Error = Void`

`fn try_from( value: File ) -> Result<Reference, <Reference as TryFrom<File>>::Error>`[src]

`impl TryFrom<Value> for DragEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<DragEvent, <DragEvent as TryFrom<Value>>::Error>`[src]

`impl TryFrom<Value> for PointerMoveEvent`[src]

`type Error = ConversionError`

`fn try_from( value: Value ) -> Result<PointerMoveEvent, <PointerMoveEvent as TryFrom<Value>>::Error>`[src]