IO.rs

pub struct IO<T>(Box<dyn FnOnce() -> T>);

impl<T: 'static> IO<T> {
    pub unsafe fn perform_io(self) -> T {
        self.0()
    }

    pub fn new(f: impl FnOnce() -> T + 'static) -> Self {
        Self(Box::new(f))
    }

    pub fn map<TResult>(self, f: impl FnOnce(T) -> TResult + 'static) -> IO<TResult> {
        IO(Box::new(move || f(unsafe { self.perform_io() })))
    }

    pub fn pure(x: T) -> IO<T> {
        IO(Box::new(move || x))
    }

    pub fn flat_map<TResult: 'static>(self, f : impl FnOnce(T) -> IO<TResult> + 'static) -> IO<TResult> {
        IO(Box::new(move || unsafe {
            let value = self.perform_io();
            f(value).perform_io()
        }))
    }
}

fn get_line() -> IO<String> {
    IO::new(|| {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).expect("Did not enter a correct string");
        s
    })
}

fn write_line(s: String) -> IO<()> {
    IO::new(move || {
        println!("{}", s);
    })
}

fn haskell_main() -> IO<()> {
    get_line().flat_map(|x| write_line(x))
}

fn haskell_runtime() {
    unsafe {
        haskell_main().perform_io();
    }
}

fn main() {
    haskell_runtime();
}