/* 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 #include #include "kernel/environment.h" #include "library/io_state.h" #include "library/expr_pair.h" #include "frontends/lean/operator_info.h" namespace lean { /** \brief Wrapper for environment/state that provides additional objects that are specific to the Lean frontend. This wrapper provides APIs for accessing/using the Lean frontend extension data in the environment. */ class frontend { environment m_env; io_state m_state; public: frontend(); frontend(environment const & env, io_state const & s); frontend mk_child() const { return frontend(m_env.mk_child(), m_state); } bool has_children() const { return m_env.has_children(); } bool has_parent() const { return m_env.has_parent(); } environment const & get_environment() const { return m_env; } operator environment const &() const { return get_environment(); } environment & get_environment() { return m_env; } operator environment &() { return get_environment(); } /** @name Environment API */ /*@{*/ level add_uvar(name const & n, level const & l) { return m_env.add_uvar(n, l); } level add_uvar(name const & n) { return m_env.add_uvar(n); } level get_uvar(name const & n) const { return m_env.get_uvar(n); } void add_definition(name const & n, expr const & t, expr const & v, bool opaque = false) { m_env.add_definition(n, t, v, opaque); } void add_theorem(name const & n, expr const & t, expr const & v) { m_env.add_theorem(n, t, v); } void add_definition(name const & n, expr const & v, bool opaque = false) { m_env.add_definition(n, v, opaque); } void add_axiom(name const & n, expr const & t) { m_env.add_axiom(n, t); } void add_var(name const & n, expr const & t) { m_env.add_var(n, t); } object const & get_object(name const & n) const { return m_env.get_object(n); } object const & find_object(name const & n) const { return m_env.find_object(n); } bool has_object(name const & n) const { return m_env.has_object(n); } typedef environment::object_iterator object_iterator; object_iterator begin_objects() const { return m_env.begin_objects(); } object_iterator end_objects() const { return m_env.end_objects(); } object_iterator begin_local_objects() const { return m_env.begin_local_objects(); } object_iterator end_local_objects() const { return m_env.end_local_objects(); } /*@}*/ /** @name Notation for parsing and pretty printing. */ /*@{*/ void add_infix(name const & opn, unsigned precedence, expr const & d); void add_infixl(name const & opn, unsigned precedence, expr const & d); void add_infixr(name const & opn, unsigned precedence, expr const & d); void add_prefix(name const & opn, unsigned precedence, expr const & d); void add_postfix(name const & opn, unsigned precedence, expr const & d); void add_mixfixl(unsigned sz, name const * opns, unsigned precedence, expr const & d); void add_mixfixr(unsigned sz, name const * opns, unsigned precedence, expr const & d); void add_mixfixc(unsigned sz, name const * opns, unsigned precedence, expr const & d); void add_mixfixo(unsigned sz, name const * opns, unsigned precedence, expr const & d); void add_mixfixl(std::initializer_list const & l, unsigned p, expr const & d) { add_mixfixl(l.size(), l.begin(), p, d); } void add_mixfixr(std::initializer_list const & l, unsigned p, expr const & d) { add_mixfixr(l.size(), l.begin(), p, d); } void add_mixfixc(std::initializer_list const & l, unsigned p, expr const & d) { add_mixfixc(l.size(), l.begin(), p, d); } void add_mixfixo(std::initializer_list const & l, unsigned p, expr const & d) { add_mixfixo(l.size(), l.begin(), p, d); } /** \brief Return the operator (if one exists) associated with the given expression. \remark If an operator is not associated with \c e, then return the null operator. \remark This is used for pretty printing. \remark If unicode is false, then only operators containing safe ASCII chars are considered. */ operator_info find_op_for(expr const & e, bool unicode) const; /** \brief Return the operator (if one exists) that can appear at the beginning of a language construct. \remark If there isn't a nud operator starting with \c n, then return the null operator. \remark This is used for parsing. */ operator_info find_nud(name const & n) const; /** \brief Return the operator (if one exists) that can appear inside of a language construct. \remark If there isn't a led operator starting with \c n, then return the null operator. \remark This is used for parsing. */ operator_info find_led(name const & n) const; /*@}*/ /** @name Implicit arguments. */ /** \brief Mark the given arguments of \c n as implicit. The bit-vector array specify the position of the implicit arguments. */ void mark_implicit_arguments(name const & n, unsigned sz, bool const * mask); void mark_implicit_arguments(name const & n, std::initializer_list const & l); void mark_implicit_arguments(expr const & n, std::initializer_list const & l); /** \brief Return true iff \c n has implicit arguments */ bool has_implicit_arguments(name const & n) const; /** \brief Return the position of the arguments that are implicit. */ std::vector const & get_implicit_arguments(name const & n) const; /** \brief This frontend associates an definition with each definition (or postulate) that has implicit arguments. The additional definition has explicit arguments, and it is called n::explicit. The explicit version can be used when the Lean frontend can't figure out the value for the implicit arguments. */ name const & get_explicit_version(name const & n) const; /** \brief Return true iff \c n is the name of the "explicit" version of an object with implicit arguments */ bool is_explicit(name const & n) const; /*@}*/ /** @name Coercions We support a very basic form of coercion. It is an expression with type T1 -> T2. This expression can be used to convert an expression of type T1 into an expression of type T2 whenever T2 is expected, but T1 was provided. */ /** \brief Add a new coercion to the frontend. It throws an exception if f does not have type T1 -> T2, or if there is already a coercion from T1 to T2. */ void add_coercion(expr const & f); /** \brief Return a coercion from given_type to expected_type if it exists. */ optional get_coercion(expr const & from_type, expr const & to_type) const; /** \brief Return the list of coercions for the given type. The result is a list of pairs (to_type, function). */ list get_coercions(expr const & from_type) const; /** \brief Return true iff the given expression is a coercion. That is, it was added using \c add_coercion. */ bool is_coercion(expr const & f) const; /*@}*/ /** @name State management. */ /*@{*/ io_state const & get_state() const { return m_state; } operator io_state const &() const { return m_state; } io_state & get_state() { return m_state; } operator io_state &() { return m_state; } options get_options() const { return m_state.get_options(); } void set_options(options const & opts) { return m_state.set_options(opts); } template void set_option(name const & n, T const & v) { m_state.set_option(n, v); } void set_regular_channel(std::shared_ptr const & out) { m_state.set_regular_channel(out); } void set_diagnostic_channel(std::shared_ptr const & out) { m_state.set_diagnostic_channel(out); } /*@}*/ }; }