elicit-rs

许可证

在以下任一许可证下发布：

• Apache 许可证 2.0 (LICENSE-APACHE 或 http://www.apache.org/licenses/LICENSE-2.0)
• MIT 许可证 (LICENSE-MIT 或 http://opensource.org/licenses/MIT)

由您选择。

贡献

除非您明确声明，否则根据 Apache-2.0 许可证定义，您有意提交以包含在作品中的任何贡献，将如上双重许可，不附加任何额外条款或条件。

lib.rs:

lib.rs

示例

Elicit

pub(crate) mod mine {
    use elicit::{elicit_define, Elicit};

    #[elicit_define(mine_elicit)]
    pub(crate) trait Mine {
        fn action(&self) -> i32;
        fn action_mut(&mut self) -> i32;
    }

    // pub(crate) mine_elicit::author as elicit_author;
    pub(crate) use mine_elicit::user as elicit_user;

    #[derive(Debug, Default, Clone, Elicit)]
    #[elicit_mod_author(mine_elicit::author)]
    pub(crate) struct MineX {}

    impl Mine for MineX {
        fn action(&self) -> i32 {
            0i32
        }
        fn action_mut(&mut self) -> i32 {
            0i32
        }
    }

    #[derive(Debug, Clone, Elicit)]
    #[elicit_mod_author(mine_elicit::author)]
    // #[elicit_from_self_field(_fsf)] // here
    pub(crate) struct MineY {
        #[elicit_from_self_field] // or here
        _fsf: mine_elicit::author::ElicitFromSelfField,
        i: i32,
    }

    impl MineY {
        pub(crate) fn new(a: i32) -> Self {
            MineY {
                _fsf: Default::default(),
                i: a,
            }
        }
        ///
        ///
        /// fn evil
        ///
        /// It is not possible to suppress calls to _weak_assign within
        /// the same module.
        ///
        #[allow(box_pointers, dead_code)]
        pub(crate) fn evil(&mut self) -> elicit::Result<()> {
            use mine_elicit::author::*;
            use std::{cell::RefCell, rc::Rc};
            self._weak_assign(Rc::<RefCell<Box<dyn ElicitBase>>>::downgrade(
                &Rc::new(RefCell::new(Box::<MineX>::default())),
            ))
        }
    }

    impl Mine for MineY {
        fn action(&self) -> i32 {
            self.i
        }
        fn action_mut(&mut self) -> i32 {
            self.i += 1;
            self.i
        }
    }
}

pub(crate) fn fire() -> elicit::Result<()> {
    use mine::elicit_user::Elicit as MineElicit;
    use mine::{MineX, MineY};

    let mut e: MineElicit;

    e = MineElicit::new(MineX::default())?;

    e.try_with(|m| -> elicit::Result<()> {
        println!("{:?}", m);
        assert!(m.action() == 0);
        Ok(())
    })?;

    let y = MineY::new(1);

    // eprintln!("{:?}", y.evil());

    e = MineElicit::new(y)?;

    e.try_with_mut(|m| -> elicit::Result<()> {
        println!("{:?}", m);
        assert!(m.action_mut() == 2);
        Ok(())
    })?;

    Ok(())
}

fire().expect("Doc-tests");