[ci skip] Remove accidentally commited scratch files

2 files changed, 0 insertions, 92 deletions

diff --git a/src/lambda.rs b/src/lambda.rs
deleted file mode 100644
index cf7b1ec..0000000
--- a/src/lambda.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// I'm only a little sorry for this.
-
-// Inline definition of anonymous functions. Examples:
-// l!(42;)
-// l!(i32 := 42)
-// l!(i: i32 := i + 42)
-// l!(i: i32, j: i32 -> i32 := i + j)
-#[macro_export]
-macro_rules! l {
-    ($body: expr) => ({ fn f() { $body } f });
-    ($res: ty := $body: expr) => ({ fn f() -> $res { $body } f });
-    ($($n: ident: $t: ty),+ := $body: expr) => ({
-        fn f($($n: $t),+) { $body } f
-    });
-    ($($n: ident: $t: ty),+ -> $res: ty := $body: expr) => ({
-        fn f($($n: $t),+) -> $res { $body } f
-    })
-}
diff --git a/src/lazy.rs b/src/lazy.rs
deleted file mode 100644
index b4f801b..0000000
--- a/src/lazy.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-#![macro_escape]
-
-use std::ptr;
-use std::cell::UnsafeCell;
-use std::ops::Deref;
-use std::boxed::FnBox;
-
-pub enum State<V> {
-    Evaluated(V),
-    Evaluating,
-    Unevaluated(Box<FnBox() -> V>)
-}
-
-pub struct Lazy<V> {
-    state: UnsafeCell<State<V>>,
-}
-
-impl<V> Lazy<V> {
-    pub fn new(f: Box<FnBox() -> V>) -> Lazy<V> {
-        Lazy { state: UnsafeCell::new(State::Unevaluated(f)) }
-    }
-
-    pub fn ready(v: V) -> Lazy<V> {
-        Lazy { state: UnsafeCell::new(State::Evaluated(v)) }
-    }
-
-    pub fn force(&mut self) {
-        self.value();
-    }
-
-    pub fn unwrap(self) -> V {
-        unsafe {
-            match self.state.into_inner() {
-                State::Unevaluated(f) => f(),
-                State::Evaluating => panic!("Illegal state, can't call unwrap during evaluation"),
-                State::Evaluated(v) => v
-            }
-        }
-    }
-
-    pub fn value(&self) -> &V {
-        unsafe {
-            let state = self.state.get();
-            match *state {
-                State::Evaluated(ref v) => v,
-                State::Evaluating => panic!("Illegal state, can't call value during evaluation"),
-                State::Unevaluated(_) => {
-                    if let State::Unevaluated(f) = ptr::replace(state, State::Evaluating) {
-                        ptr::replace(state, State::Evaluated(f()));
-                    }
-                    if let State::Evaluated(ref v) = *state { return v }
-                    unreachable!()
-                }
-            }
-        }
-    }
-}
-
-impl<V> Deref for Lazy<V> {
-    type Target = V;
-    fn deref(&self) -> &V { self.value() }
-}
-
-#[macro_export]
-macro_rules! lazy {
-    (@as_expr $val: expr) => { $val };
-    ($($val: tt)*) => { Lazy::new(Box::new(move || lazy![@as_expr { $($val)* }])) };
-}
-
-#[macro_export]
-macro_rules! eager {
-    (@as_expr $val: expr) => { $val };
-    ($($val: tt)*) => { Lazy::<_>::ready(eager![@as_expr { $($val)* }]) };
-}