chore: use std::future::Future instead

packages/core/src/scheduler/mod.rs

@@ -33,17 +33,7 @@ pub enum SchedulerMsg {
 
 use std::{cell::RefCell, rc::Rc};
 
-#[derive(Clone)]
-pub(crate) struct Scheduler(Rc<HandleInner>);
-
-impl std::ops::Deref for Scheduler {
-    type Target = HandleInner;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-pub struct HandleInner {
+pub(crate) struct Scheduler {
     pub sender: futures_channel::mpsc::UnboundedSender<SchedulerMsg>,
 
     /// Tasks created with cx.spawn
@@ -54,11 +44,11 @@ pub struct HandleInner {
 }
 
 impl Scheduler {
-    pub fn new(sender: futures_channel::mpsc::UnboundedSender<SchedulerMsg>) -> Self {
-        Self(Rc::new(HandleInner {
+    pub fn new(sender: futures_channel::mpsc::UnboundedSender<SchedulerMsg>) -> Rc<Self> {
+        Rc::new(Scheduler {
             sender,
             tasks: RefCell::new(Slab::new()),
             leaves: RefCell::new(Slab::new()),
-        }))
+        })
     }
 }

packages/core/src/scheduler/suspense.rs

@@ -1,17 +1,12 @@
+use super::{waker::RcWake, SchedulerMsg};
+use crate::{innerlude::Mutations, Element, ScopeId};
+use std::future::Future;
 use std::{
     cell::{Cell, RefCell},
     collections::HashSet,
     rc::Rc,
 };
 
-use super::{waker::RcWake, SchedulerMsg};
-use crate::{
-    innerlude::{Mutation, Mutations},
-    Element, ScopeId,
-};
-
-use futures_util::Future;
-
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct SuspenseId(pub usize);
 

packages/core/src/scheduler/task.rs

@@ -1,30 +1,15 @@
-use std::{
-    cell::{RefCell, UnsafeCell},
-    marker::PhantomData,
-    mem::{self, MaybeUninit},
-    ops::DerefMut,
-    pin::Pin,
-    process::Output,
-    rc::Rc,
-    sync::Arc,
-    task::Poll,
-};
-
-use futures_util::{pin_mut, Future, FutureExt};
-use slab::Slab;
-use std::task::{Context, RawWaker, RawWakerVTable, Waker};
-
-use crate::{Element, ScopeId};
-
-use super::{waker::RcWake, HandleInner, Scheduler, SchedulerMsg};
+use super::{waker::RcWake, Scheduler, SchedulerMsg};
+use crate::ScopeId;
+use std::future::Future;
+use std::task::Context;
+use std::{cell::UnsafeCell, pin::Pin, rc::Rc, task::Poll};
 
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct TaskId(pub usize);
 
 /// the task itself is the waker
-
-pub struct LocalTask {
+pub(crate) struct LocalTask {
     pub id: TaskId,
     pub scope: ScopeId,
     pub tx: futures_channel::mpsc::UnboundedSender<SchedulerMsg>,
@@ -41,14 +26,14 @@ impl LocalTask {
         // safety: the waker owns its task and everythig is single threaded
         let fut = unsafe { &mut *self.task.get() };
 
-        match fut.poll_unpin(&mut cx) {
+        match Pin::new(fut).poll(&mut cx) {
             Poll::Ready(_) => true,
             _ => false,
         }
     }
 }
 
-impl HandleInner {
+impl Scheduler {
     pub fn spawn(&self, scope: ScopeId, task: impl Future<Output = ()> + 'static) -> TaskId {
         let mut tasks = self.tasks.borrow_mut();
         let entry = tasks.vacant_entry();