lean2/src/util/lazy_list.h
Leonardo de Moura 443022d840 feat(util/lazy_list): add is_nil predicate
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2014-06-26 18:51:35 -07:00

118 lines
3.5 KiB
C++

/*
Copyright (c) 2013 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Leonardo de Moura
*/
#pragma once
#include <utility>
#include "util/debug.h"
#include "util/rc.h"
#include "util/optional.h"
namespace lean {
/**
\brief ML-like lazy lists.
*/
template<typename T>
class lazy_list {
public:
typedef optional<std::pair<T, lazy_list>> maybe_pair; // head and tail pair
private:
class cell_base {
MK_LEAN_RC();
void dealloc() { delete this; }
public:
cell_base():m_rc(0) {}
virtual ~cell_base() {}
virtual maybe_pair pull() const = 0;
};
template<typename F>
class cell : public cell_base {
F m_f;
public:
cell(F && f):cell_base(), m_f(f) {}
virtual ~cell() {}
virtual maybe_pair pull() const { return m_f(); }
};
class cell_singleton : public cell_base {
T m_val;
public:
cell_singleton(T const & v):cell_base(), m_val(v) {}
cell_singleton(T && v):cell_base(), m_val(std::move(v)) {}
virtual ~cell_singleton() {}
virtual maybe_pair pull() const {
lazy_list empty;
return maybe_pair(m_val, empty);
}
};
class cell_pair : public cell_base {
T m_head;
lazy_list m_tail;
public:
cell_pair(T const & h, lazy_list const & t):cell_base(), m_head(h), m_tail(t) {}
virtual ~cell_pair() {}
virtual maybe_pair pull() const {
return maybe_pair(m_head, m_tail);
}
};
cell_base * m_ptr;
public:
lazy_list():m_ptr(nullptr) {}
lazy_list(lazy_list const & s):m_ptr(s.m_ptr) { if (m_ptr) m_ptr->inc_ref(); }
lazy_list(lazy_list && s):m_ptr(s.m_ptr) { s.m_ptr = nullptr; }
lazy_list(T const & v):m_ptr(new cell_singleton(v)) { m_ptr->inc_ref(); }
lazy_list(T && v):m_ptr(new cell_singleton(std::forward<T>(v))) { m_ptr->inc_ref(); }
lazy_list(T const & h, lazy_list const & t):m_ptr(new cell_pair(h, t)) { m_ptr->inc_ref(); }
~lazy_list() { if (m_ptr) m_ptr->dec_ref(); }
lazy_list & operator=(lazy_list const & s) { LEAN_COPY_REF(s); }
lazy_list & operator=(lazy_list && s) { LEAN_MOVE_REF(s); }
/**
\brief Return true if the lazy_list is definitely empty. This is an approximated test (i.e., it is not an "iff").
Here are examples where this method will return true.
1) lazy_list empty;
lean_assert(is_nil(empty));
2) lazy_list singleton(v);
maybe_pair p = singleton.pull();
lean_assert(p);
lean_assert(is_nil(p->second));
3) assume is_nil(l), then
lazy_list singleton(v, l);
maybe_pair p = singleton.pull();
lean_assert(p);
lean_assert(is_nil(p->second));
*/
bool is_nil() const { return m_ptr == nullptr; }
maybe_pair pull() const {
if (m_ptr)
return m_ptr->pull();
else
return maybe_pair();
}
friend T head(lazy_list const & l) { return l.pull()->first; }
friend lazy_list tail(lazy_list const & l) { return l.pull()->second; }
template<typename F>
static lazy_list mk_lazy_list_core(F && f) {
lazy_list r;
r.m_ptr = new cell<F>(std::forward<F>(f));
r.m_ptr->inc_ref();
return r;
}
};
template<typename T, typename F>
lazy_list<T> mk_lazy_list(F && f) {
return lazy_list<T>::mk_lazy_list_core(std::forward<F>(f));
}
}