update

Author: nojima

io-monad-in-rust/src/cached.rs

@@ -1,12 +1,12 @@
 use std::cell::{Cell, OnceCell};
 
-pub struct Cached<T> {
-    init: Cell<Option<Box<dyn FnOnce() -> T>>>,
+pub struct Cached<'a, T> {
+    init: Cell<Option<Box<dyn FnOnce() -> T + 'a>>>,
     value: OnceCell<T>,
 }
 
-impl<T> Cached<T> {
-    pub fn new(init: impl FnOnce() -> T + 'static) -> Self {
+impl<'a, T> Cached<'a, T> {
+    pub fn new(init: impl FnOnce() -> T + 'a) -> Self {
         Self {
             init: Cell::new(Some(Box::new(init))),
             value: OnceCell::new(),
@@ -16,36 +16,36 @@ impl<T> Cached<T> {
     pub fn get(&self) -> &T {
         self.value.get_or_init(|| {
             let Some(init) = self.init.take() else {
-                panic!("[bug] init function called twice!")
+                unreachable!("The init function should be never called twice");
             };
             init()
         })
     }
+
+    pub fn take(self) -> T {
+        let _ = self.get();
+        let Some(value) = self.value.into_inner() else {
+            unreachable!("The value should be always cached after calling get()");
+        };
+        value
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[derive(Debug)]
-    struct Foo {
-        #[allow(dead_code)]
-        message: String,
-    }
-
-    impl Drop for Foo {
-        fn drop(&mut self) {
-            println!("Dropped: {self:?}")
-        }
-    }
-
     #[test]
-    fn test() {
-        let msg = "hello".to_owned();
-        let c1 = Cached::new(|| Foo { message: msg });
-        let msg2 = "hello".to_owned();
-        let _c2 = Cached::new(|| Foo { message: msg2 });
-        println!("{:?} world", c1.get());
-        println!("{:?} world again", c1.get());
+    fn test_cached() {
+        let mut n_called = 0;
+        let cached = Cached::new(|| {
+            n_called += 1;
+            "hello".to_string()
+        });
+        assert_eq!(cached.get(), "hello");
+        assert_eq!(cached.get(), "hello");
+        assert_eq!(cached.get(), "hello");
+        drop(cached);
+        assert_eq!(n_called, 1);
     }
 }

io-monad-in-rust/src/io_monad.rs

@@ -0,0 +1,45 @@
+use crate::cached::Cached;
+
+pub struct IO<A>(Cached<'static, A>);
+
+impl<A: 'static> IO<A> {
+    pub fn pure(a: A) -> IO<A> {
+        IO(Cached::new(|| a))
+    }
+
+    pub fn map<B>(self, f: impl FnOnce(A) -> B + 'static) -> IO<B> {
+        IO(Cached::new(move || f(self.0.take())))
+    }
+
+    pub fn apply<B>(self, f: IO<impl FnOnce(A) -> B + 'static>) -> IO<B> {
+        IO(Cached::new(move || {
+            let f = f.0.take();
+            f(self.0.take())
+        }))
+    }
+
+    pub fn bind<B>(self, f: impl FnOnce(A) -> IO<B> + 'static) -> IO<B> {
+        IO(Cached::new(move || {
+            let x = f(self.0.take());
+            x.0.take()
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::cached::Cached;
+
+    use super::IO;
+
+    fn put_str_ln(s: String) -> IO<()> {
+        IO(Cached::new(move || println!("{s}")))
+    }
+
+    #[test]
+    fn test() {
+        let action1 = IO::pure("hello".to_string());
+        let action2 = action1.bind(|s| put_str_ln(s));
+        action2.0.take();
+    }
+}