list_terms.hh

// This file is a part of Aurelia.
// Copyright (C) 2010  Valentin David
// Copyright (C) 2010  University of Bergen
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#ifndef __LIST_TERMS_HH
# define __LIST_TERMS_HH

# include "term_utils.hh"
# include "../patterns/pattern_utils.hh"

namespace aurelia {

  template <typename a>
  struct list;

  struct cons_constr {};
  namespace patterns {
    pattern_generator<cons_constr> cons;
  }

  template <typename a>
  struct get_tuple<list<a>, cons_constr> {
    typedef std::tuple<a, list<a> > tuple;
  };

  struct nil_constr {};
  namespace patterns {
    pattern_generator<nil_constr> nil;
  }

  template <typename a>
  struct get_tuple<list<a>, nil_constr> {
    typedef std::tuple<> tuple;
  };

  template <typename a>
  struct cons_term;

  template <typename a>
  struct nil_term;

  template <typename a>
  struct list: public term<list<a>, nil_constr, cons_constr> {
    typedef term<list<a>, nil_constr, cons_constr> super;
    list() = default;
    list(const super& other): super(other) {}
    list(super&& other): super(std::move(other)) {}
  };

  template <typename a>
  struct cons_term: public std_term<cons_term<a>, cons_constr, list<a> > {
    typedef std_term<cons_term<a>, cons_constr, list<a> > super;
    cons_term(a h, const list<a>& t): super(typename super::tuple(h, t)) {}
    cons_term(const cons_term& other): super(other) {}
  };

  template <typename a>
  struct build_type<list<a>, cons_constr> {
    typedef cons_term<a> type;
  };

  template <typename a>
  struct nil_term: public std_term<nil_term<a>, nil_constr, list<a> > {
    typedef std_term<nil_term<a>, nil_constr, list<a> > super;
    nil_term(): super(typename super::tuple()) {}
    nil_term(const nil_term& other): super(other) {}
  };

  template <typename a>
  struct build_type<list<a>, nil_constr> {
    typedef nil_term<a> type;
  };

  template <typename a>
  struct term_model<list<a> > {
    struct model {
      typedef list<a> type;
    };
  };

}

#endif