bug#24821: Emacs 25.1.1

bug#24821: Emacs 25.1.1

[Felipe Magno de Almeida]

[-- Attachment #1: Type: text/plain, Size: 339 bytes --]

The attached content when displayed in compilation-mode causes emacs
to crash in my machine.

I use a arch linux distribution.

It even crashes if I do M-x compilation-mode on the file itself,
instead of running it through M-x compile. And it crashes every single
time, so it is easily reproduceable.

Regards,
-- 
Felipe Magno de Almeida

[-- Attachment #2: emacs-bug.txt --]
[-- Type: text/plain, Size: 269760 bytes --]

Making check in src
make  check-recursive
  CXX      bin/eolian_mono/bin_eolian_mono_eolian_mono-eolian_mono.o
In file included from ../../src/bin/eolian_mono/eolian_mono/klass.hh:12:0,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/bin/eolian_mono/eolian_mono/function_definition.hh: In member function ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const’:
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:40:96: error: expected ‘)’ before string constant
         << (return_type == "void" ? "":"return ") << string << "(handle" << *(", " << argument)");"
                                                                                                ^~~~
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
../../src/lib/eolian_cxx/grammar/string.hpp:55:36: error: no matching function for call to ‘begin(const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                          ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/bits/range_access.h:36:0,
                 from /usr/include/c++/6.2.1/string:51,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/initializer_list:89:5: note: candidate: template<class _Tp> constexpr const _Tp* std::begin(std::initializer_list<_Tp>)
     begin(initializer_list<_Tp> __ils) noexcept
     ^~~~~
/usr/include/c++/6.2.1/initializer_list:89:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:55:36: note:   ‘std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘std::initializer_list<_Tp>’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                          ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:48:5: note: candidate: template<class _Container> decltype (__cont.begin()) std::begin(_Container&)
     begin(_Container& __cont) -> decltype(__cont.begin())
     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:48:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.begin()) std::begin(_Container&) [with _Container = const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:55:36:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:48:50: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘begin’
     begin(_Container& __cont) -> decltype(__cont.begin())
                                           ~~~~~~~^~~~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:58:5: note: candidate: template<class _Container> decltype (__cont.begin()) std::begin(const _Container&)
     begin(const _Container& __cont) -> decltype(__cont.begin())
     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:58:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.begin()) std::begin(const _Container&) [with _Container = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:55:36:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:58:56: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘begin’
     begin(const _Container& __cont) -> decltype(__cont.begin())
                                                 ~~~~~~~^~~~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:87:5: note: candidate: template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::begin(_Tp (&)[_Nm])
     begin(_Tp (&__arr)[_Nm])
     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:87:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:55:36: note:   mismatched types ‘_Tp [_Nm]’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                          ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:104:31: note: candidate: template<class _Tp> _Tp* std::begin(std::valarray<_Tp>&)
   template<typename _Tp> _Tp* begin(valarray<_Tp>&);
                               ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:104:31: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:55:36: note:   types ‘std::valarray<_Tp>’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ have incompatible cv-qualifiers
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                          ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:105:37: note: candidate: template<class _Tp> const _Tp* std::begin(const std::valarray<_Tp>&)
   template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
                                     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:105:37: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:55:36: note:   ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘const std::valarray<_Tp>’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                          ~~~~~~~~~~^~~~~~~~~~~
../../src/lib/eolian_cxx/grammar/string.hpp:55:57: error: no matching function for call to ‘end(const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                                                 ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/bits/range_access.h:36:0,
                 from /usr/include/c++/6.2.1/string:51,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/initializer_list:99:5: note: candidate: template<class _Tp> constexpr const _Tp* std::end(std::initializer_list<_Tp>)
     end(initializer_list<_Tp> __ils) noexcept
     ^~~
/usr/include/c++/6.2.1/initializer_list:99:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:55:57: note:   ‘std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘std::initializer_list<_Tp>’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                                                 ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:68:5: note: candidate: template<class _Container> decltype (__cont.end()) std::end(_Container&)
     end(_Container& __cont) -> decltype(__cont.end())
     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:68:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.end()) std::end(_Container&) [with _Container = const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:55:57:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:68:48: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘end’
     end(_Container& __cont) -> decltype(__cont.end())
                                         ~~~~~~~^~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:78:5: note: candidate: template<class _Container> decltype (__cont.end()) std::end(const _Container&)
     end(const _Container& __cont) -> decltype(__cont.end())
     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:78:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.end()) std::end(const _Container&) [with _Container = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:55:57:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:78:54: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘end’
     end(const _Container& __cont) -> decltype(__cont.end())
                                               ~~~~~~~^~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:97:5: note: candidate: template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::end(_Tp (&)[_Nm])
     end(_Tp (&__arr)[_Nm])
     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:97:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:55:57: note:   mismatched types ‘_Tp [_Nm]’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                                                 ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:106:31: note: candidate: template<class _Tp> _Tp* std::end(std::valarray<_Tp>&)
   template<typename _Tp> _Tp* end(valarray<_Tp>&);
                               ^~~
/usr/include/c++/6.2.1/bits/range_access.h:106:31: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:55:57: note:   types ‘std::valarray<_Tp>’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ have incompatible cv-qualifiers
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                                                 ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:107:37: note: candidate: template<class _Tp> const _Tp* std::end(const std::valarray<_Tp>&)
   template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
                                     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:107:37: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:55:57: note:   ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘const std::valarray<_Tp>’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::toupper);
                                                 ~~~~~~~~^~~~~~~~~~~
../../src/lib/eolian_cxx/grammar/string.hpp:59:36: error: no matching function for call to ‘begin(const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                          ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/bits/range_access.h:36:0,
                 from /usr/include/c++/6.2.1/string:51,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/initializer_list:89:5: note: candidate: template<class _Tp> constexpr const _Tp* std::begin(std::initializer_list<_Tp>)
     begin(initializer_list<_Tp> __ils) noexcept
     ^~~~~
/usr/include/c++/6.2.1/initializer_list:89:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:59:36: note:   ‘std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘std::initializer_list<_Tp>’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                          ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:48:5: note: candidate: template<class _Container> decltype (__cont.begin()) std::begin(_Container&)
     begin(_Container& __cont) -> decltype(__cont.begin())
     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:48:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.begin()) std::begin(_Container&) [with _Container = const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:59:36:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:48:50: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘begin’
     begin(_Container& __cont) -> decltype(__cont.begin())
                                           ~~~~~~~^~~~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:58:5: note: candidate: template<class _Container> decltype (__cont.begin()) std::begin(const _Container&)
     begin(const _Container& __cont) -> decltype(__cont.begin())
     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:58:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.begin()) std::begin(const _Container&) [with _Container = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:59:36:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:58:56: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘begin’
     begin(const _Container& __cont) -> decltype(__cont.begin())
                                                 ~~~~~~~^~~~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:87:5: note: candidate: template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::begin(_Tp (&)[_Nm])
     begin(_Tp (&__arr)[_Nm])
     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:87:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:59:36: note:   mismatched types ‘_Tp [_Nm]’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                          ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:104:31: note: candidate: template<class _Tp> _Tp* std::begin(std::valarray<_Tp>&)
   template<typename _Tp> _Tp* begin(valarray<_Tp>&);
                               ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:104:31: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:59:36: note:   types ‘std::valarray<_Tp>’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ have incompatible cv-qualifiers
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                          ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:105:37: note: candidate: template<class _Tp> const _Tp* std::begin(const std::valarray<_Tp>&)
   template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
                                     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:105:37: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:59:36: note:   ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘const std::valarray<_Tp>’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                          ~~~~~~~~~~^~~~~~~~~~~
../../src/lib/eolian_cxx/grammar/string.hpp:59:57: error: no matching function for call to ‘end(const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                                                 ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/bits/range_access.h:36:0,
                 from /usr/include/c++/6.2.1/string:51,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/initializer_list:99:5: note: candidate: template<class _Tp> constexpr const _Tp* std::end(std::initializer_list<_Tp>)
     end(initializer_list<_Tp> __ils) noexcept
     ^~~
/usr/include/c++/6.2.1/initializer_list:99:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:59:57: note:   ‘std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘std::initializer_list<_Tp>’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                                                 ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:68:5: note: candidate: template<class _Container> decltype (__cont.end()) std::end(_Container&)
     end(_Container& __cont) -> decltype(__cont.end())
     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:68:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.end()) std::end(_Container&) [with _Container = const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:59:57:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:68:48: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘end’
     end(_Container& __cont) -> decltype(__cont.end())
                                         ~~~~~~~^~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:78:5: note: candidate: template<class _Container> decltype (__cont.end()) std::end(const _Container&)
     end(const _Container& __cont) -> decltype(__cont.end())
     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:78:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.end()) std::end(const _Container&) [with _Container = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:59:57:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:78:54: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘end’
     end(const _Container& __cont) -> decltype(__cont.end())
                                               ~~~~~~~^~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:97:5: note: candidate: template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::end(_Tp (&)[_Nm])
     end(_Tp (&__arr)[_Nm])
     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:97:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:59:57: note:   mismatched types ‘_Tp [_Nm]’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                                                 ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:106:31: note: candidate: template<class _Tp> _Tp* std::end(std::valarray<_Tp>&)
   template<typename _Tp> _Tp* end(valarray<_Tp>&);
                               ^~~
/usr/include/c++/6.2.1/bits/range_access.h:106:31: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:59:57: note:   types ‘std::valarray<_Tp>’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ have incompatible cv-qualifiers
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                                                 ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:107:37: note: candidate: template<class _Tp> const _Tp* std::end(const std::valarray<_Tp>&)
   template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
                                     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:107:37: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:59:57: note:   ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘const std::valarray<_Tp>’
           std::transform(std::begin(attribute), std::end(attribute), sink, &::tolower);
                                                 ~~~~~~~~^~~~~~~~~~~
../../src/lib/eolian_cxx/grammar/string.hpp:63:31: error: no matching function for call to ‘begin(const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)’
           std::copy(std::begin(attribute), std::end(attribute), sink);
                     ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/bits/range_access.h:36:0,
                 from /usr/include/c++/6.2.1/string:51,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/initializer_list:89:5: note: candidate: template<class _Tp> constexpr const _Tp* std::begin(std::initializer_list<_Tp>)
     begin(initializer_list<_Tp> __ils) noexcept
     ^~~~~
/usr/include/c++/6.2.1/initializer_list:89:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:63:31: note:   ‘std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘std::initializer_list<_Tp>’
           std::copy(std::begin(attribute), std::end(attribute), sink);
                     ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:48:5: note: candidate: template<class _Container> decltype (__cont.begin()) std::begin(_Container&)
     begin(_Container& __cont) -> decltype(__cont.begin())
     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:48:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.begin()) std::begin(_Container&) [with _Container = const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:63:31:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:48:50: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘begin’
     begin(_Container& __cont) -> decltype(__cont.begin())
                                           ~~~~~~~^~~~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:58:5: note: candidate: template<class _Container> decltype (__cont.begin()) std::begin(const _Container&)
     begin(const _Container& __cont) -> decltype(__cont.begin())
     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:58:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.begin()) std::begin(const _Container&) [with _Container = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:63:31:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:58:56: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘begin’
     begin(const _Container& __cont) -> decltype(__cont.begin())
                                                 ~~~~~~~^~~~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:87:5: note: candidate: template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::begin(_Tp (&)[_Nm])
     begin(_Tp (&__arr)[_Nm])
     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:87:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:63:31: note:   mismatched types ‘_Tp [_Nm]’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’
           std::copy(std::begin(attribute), std::end(attribute), sink);
                     ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:104:31: note: candidate: template<class _Tp> _Tp* std::begin(std::valarray<_Tp>&)
   template<typename _Tp> _Tp* begin(valarray<_Tp>&);
                               ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:104:31: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:63:31: note:   types ‘std::valarray<_Tp>’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ have incompatible cv-qualifiers
           std::copy(std::begin(attribute), std::end(attribute), sink);
                     ~~~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:105:37: note: candidate: template<class _Tp> const _Tp* std::begin(const std::valarray<_Tp>&)
   template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
                                     ^~~~~
/usr/include/c++/6.2.1/bits/range_access.h:105:37: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:63:31: note:   ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘const std::valarray<_Tp>’
           std::copy(std::begin(attribute), std::end(attribute), sink);
                     ~~~~~~~~~~^~~~~~~~~~~
../../src/lib/eolian_cxx/grammar/string.hpp:63:52: error: no matching function for call to ‘end(const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)’
           std::copy(std::begin(attribute), std::end(attribute), sink);
                                            ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/bits/range_access.h:36:0,
                 from /usr/include/c++/6.2.1/string:51,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/initializer_list:99:5: note: candidate: template<class _Tp> constexpr const _Tp* std::end(std::initializer_list<_Tp>)
     end(initializer_list<_Tp> __ils) noexcept
     ^~~
/usr/include/c++/6.2.1/initializer_list:99:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:63:52: note:   ‘std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘std::initializer_list<_Tp>’
           std::copy(std::begin(attribute), std::end(attribute), sink);
                                            ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:68:5: note: candidate: template<class _Container> decltype (__cont.end()) std::end(_Container&)
     end(_Container& __cont) -> decltype(__cont.end())
     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:68:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.end()) std::end(_Container&) [with _Container = const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:63:52:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:68:48: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘end’
     end(_Container& __cont) -> decltype(__cont.end())
                                         ~~~~~~~^~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:78:5: note: candidate: template<class _Container> decltype (__cont.end()) std::end(const _Container&)
     end(const _Container& __cont) -> decltype(__cont.end())
     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:78:5: note:   template argument deduction/substitution failed:
/usr/include/c++/6.2.1/bits/range_access.h: In substitution of ‘template<class _Container> decltype (__cont.end()) std::end(const _Container&) [with _Container = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >]’:
../../src/lib/eolian_cxx/grammar/string.hpp:63:52:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:78:54: error: ‘const class std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ has no member named ‘end’
     end(const _Container& __cont) -> decltype(__cont.end())
                                               ~~~~~~~^~~
../../src/lib/eolian_cxx/grammar/string.hpp: In instantiation of ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:33:91:   required from ‘bool eolian_mono::argument_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:180:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((! efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = const char*; R = eolian_mono::argument_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::parameter_def; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = const char*; R = eolian_mono::argument_generator]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   [ skipping 2 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/range_access.h:97:5: note: candidate: template<class _Tp, long unsigned int _Nm> constexpr _Tp* std::end(_Tp (&)[_Nm])
     end(_Tp (&__arr)[_Nm])
     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:97:5: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:63:52: note:   mismatched types ‘_Tp [_Nm]’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’
           std::copy(std::begin(attribute), std::end(attribute), sink);
                                            ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:106:31: note: candidate: template<class _Tp> _Tp* std::end(std::valarray<_Tp>&)
   template<typename _Tp> _Tp* end(valarray<_Tp>&);
                               ^~~
/usr/include/c++/6.2.1/bits/range_access.h:106:31: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:63:52: note:   types ‘std::valarray<_Tp>’ and ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ have incompatible cv-qualifiers
           std::copy(std::begin(attribute), std::end(attribute), sink);
                                            ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/string:51:0,
                 from /usr/include/c++/6.2.1/bits/locale_classes.h:40,
                 from /usr/include/c++/6.2.1/bits/ios_base.h:41,
                 from /usr/include/c++/6.2.1/ios:42,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/range_access.h:107:37: note: candidate: template<class _Tp> const _Tp* std::end(const std::valarray<_Tp>&)
   template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
                                     ^~~
/usr/include/c++/6.2.1/bits/range_access.h:107:37: note:   template argument deduction/substitution failed:
In file included from ../../src/lib/eolian_cxx/grammar/klass_def.hpp:7:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:5,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/string.hpp:63:52: note:   ‘const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >’ is not derived from ‘const std::valarray<_Tp>’
           std::copy(std::begin(attribute), std::end(attribute), sink);
                                            ~~~~~~~~^~~~~~~~~~~
In file included from /usr/include/c++/6.2.1/algorithm:62:0,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:11:
/usr/include/c++/6.2.1/bits/stl_algo.h: In instantiation of ‘_OIter std::transform(_IIter, _IIter, _OIter, _UnaryOperation) [with _IIter = __gnu_cxx::__normal_iterator<const efl::eolian::grammar::attributes::parameter_def*, std::vector<efl::eolian::grammar::attributes::parameter_def> >; _OIter = std::ostream_iterator<char>; _UnaryOperation = int (*)(int) throw ()]’:
../../src/lib/eolian_cxx/grammar/string.hpp:55:25:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::parameter_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:149:56:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && (! efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value)) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = efl::eolian::grammar::string_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::lazy_offset_tuple<2, const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && (! efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value)) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>; R = efl::eolian::grammar::string_generator_terminal; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>; R = efl::eolian::grammar::string_generator_terminal]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:160:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:23:33:   [ skipping 3 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:23:33:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/stl_algo.h:4177:24: error: cannot convert ‘const efl::eolian::grammar::attributes::parameter_def’ to ‘int’ in argument passing
  *__result = __unary_op(*__first);
              ~~~~~~~~~~^~~~~~~~~~
In file included from /usr/include/c++/6.2.1/bits/char_traits.h:39:0,
                 from /usr/include/c++/6.2.1/ios:40,
                 from /usr/include/c++/6.2.1/ostream:38,
                 from /usr/include/c++/6.2.1/iostream:39,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:2:
/usr/include/c++/6.2.1/bits/stl_algobase.h: In instantiation of ‘static _OI std::__copy_move<false, false, std::random_access_iterator_tag>::__copy_m(_II, _II, _OI) [with _II = const efl::eolian::grammar::attributes::parameter_def*; _OI = std::ostream_iterator<char>]’:
/usr/include/c++/6.2.1/bits/stl_algobase.h:386:44:   required from ‘_OI std::__copy_move_a(_II, _II, _OI) [with bool _IsMove = false; _II = const efl::eolian::grammar::attributes::parameter_def*; _OI = std::ostream_iterator<char>]’
/usr/include/c++/6.2.1/bits/stl_algobase.h:422:45:   required from ‘_OI std::__copy_move_a2(_II, _II, _OI) [with bool _IsMove = false; _II = __gnu_cxx::__normal_iterator<const efl::eolian::grammar::attributes::parameter_def*, std::vector<efl::eolian::grammar::attributes::parameter_def> >; _OI = std::ostream_iterator<char>]’
/usr/include/c++/6.2.1/bits/stl_algobase.h:455:8:   required from ‘_OI std::copy(_II, _II, _OI) [with _II = __gnu_cxx::__normal_iterator<const efl::eolian::grammar::attributes::parameter_def*, std::vector<efl::eolian::grammar::attributes::parameter_def> >; _OI = std::ostream_iterator<char>]’
../../src/lib/eolian_cxx/grammar/string.hpp:63:20:   required from ‘bool efl::eolian::grammar::string_generator::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::parameter_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:149:56:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && (! efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value)) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = efl::eolian::grammar::string_generator; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::lazy_offset_tuple<2, const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && (! efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value)) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   [ skipping 6 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:23:33:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
/usr/include/c++/6.2.1/bits/stl_algobase.h:324:18: error: no match for ‘operator=’ (operand types are ‘std::ostream_iterator<char>’ and ‘const efl::eolian::grammar::attributes::parameter_def’)
        *__result = *__first;
        ~~~~~~~~~~^~~~~~~~~~
In file included from /usr/include/c++/6.2.1/iterator:66:0,
                 from ../../src/bindings/cxx/eina_cxx/eina_iterator.hh:9,
                 from ../../src/bindings/cxx/eina_cxx/Eina.hh:8,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:22:
/usr/include/c++/6.2.1/bits/stream_iterator.h:193:7: note: candidate: std::ostream_iterator<_Tp, _CharT, _Traits>& std::ostream_iterator<_Tp, _CharT, _Traits>::operator=(const _Tp&) [with _Tp = char; _CharT = char; _Traits = std::char_traits<char>]
       operator=(const _Tp& __value)
       ^~~~~~~~
/usr/include/c++/6.2.1/bits/stream_iterator.h:193:7: note:   no known conversion for argument 1 from ‘const efl::eolian::grammar::attributes::parameter_def’ to ‘const char&’
/usr/include/c++/6.2.1/bits/stream_iterator.h:154:11: note: candidate: constexpr std::ostream_iterator<char>& std::ostream_iterator<char>::operator=(const std::ostream_iterator<char>&)
     class ostream_iterator
           ^~~~~~~~~~~~~~~~
/usr/include/c++/6.2.1/bits/stream_iterator.h:154:11: note:   no known conversion for argument 1 from ‘const efl::eolian::grammar::attributes::parameter_def’ to ‘const std::ostream_iterator<char>&’
In file included from ../../src/bin/eolian_mono/eolian_mono/klass.hh:8:0,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/list.hpp: In instantiation of ‘bool efl::eolian::grammar::list_generator<G, S>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::__cxx11::basic_string<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; G = eolian_mono::parameter_generator; S = const char*]’:
../../src/lib/eolian_cxx/grammar/attributes.hpp:149:56:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && (! efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value)) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*>; OutputIterator = std::ostream_iterator<char>; Attribute = efl::eolian::grammar::attributes::lazy_offset_tuple<1, const std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && (! efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value)) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:26:36:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*>; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*>]’
../../src/lib/eolian_cxx/grammar/attributes.hpp:160:48:   required from ‘bool efl::eolian::grammar::attributes::generate(const Generator&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type*) [with Generator = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<((efl::eolian::grammar::type_traits::is_explicit_tuple<Attribute>::value && efl::eolian::grammar::type_traits::accepts_tuple<Generator>::value) && (efl::eolian::grammar::type_traits::attributes_needed<G>::value != 0))>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:23:33:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >; R = const char*; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   [ skipping 11 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]
../../src/lib/eolian_cxx/grammar/sequence.hpp:23:33:   required from ‘bool efl::eolian::grammar::generate_sequence(const L&, const R&, OutputIterator, const Attribute&, const Context&, typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type*) [with L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >; OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; typename std::enable_if<efl::eolian::grammar::type_traits::is_tuple<Attribute>::value>::type = void]’
../../src/lib/eolian_cxx/grammar/sequence.hpp:109:40:   required from ‘bool efl::eolian::grammar::sequence_generator<L, R>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> >, std::vector<efl::eolian::grammar::attributes::parameter_def, std::allocator<efl::eolian::grammar::attributes::parameter_def> > >; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; L = efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::sequence_generator<efl::eolian::grammar::scope_tab_terminal, const char*>, std::__cxx11::basic_string<char> >, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>, efl::eolian::grammar::list_generator<eolian_mono::parameter_generator, const char*> >, const char*>, const char*>, efl::eolian::grammar::string_generator_terminal>, const char*>; R = efl::eolian::grammar::kleene_generator<efl::eolian::grammar::sequence_generator<const char*, eolian_mono::argument_generator> >]’
../../src/bin/eolian_mono/eolian_mono/function_definition.hh:37:8:   required from ‘bool eolian_mono::function_definition_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::function_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/lib/eolian_cxx/grammar/kleene.hpp:20:14:   required from ‘bool efl::eolian::grammar::kleene_generator<Generator>::generate(OutputIterator, const Attribute&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Attribute = std::vector<efl::eolian::grammar::attributes::function_def>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>; Generator = eolian_mono::function_definition_generator]’
../../src/bin/eolian_mono/eolian_mono/klass.hh:112:13:   required from ‘bool eolian_mono::klass::generate(OutputIterator, const efl::eolian::grammar::attributes::klass_def&, const Context&) const [with OutputIterator = std::ostream_iterator<char>; Context = efl::eolian::grammar::context_cons<eolian_mono::library_context>]’
../../src/bin/eolian_mono/eolian_mono.cc:95:139:   required from here
../../src/lib/eolian_cxx/grammar/list.hpp:24:15: error: no matching function for call to ‘eolian_mono::parameter_generator::generate(std::ostream_iterator<char>&, const char&, const efl::eolian::grammar::context_cons<eolian_mono::library_context>&)’
            if(!generator.generate(sink, c, context))
                
In file included from ../../src/bin/eolian_mono/eolian_mono/function_definition.hh:11:0,
                 from ../../src/bin/eolian_mono/eolian_mono/klass.hh:12,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/bin/eolian_mono/eolian_mono/parameter.hh:20:9: note: candidate: template<class OutputIterator, class Context> bool eolian_mono::parameter_generator::generate(OutputIterator, const efl::eolian::grammar::attributes::parameter_def&, const Context&) const
    bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
         ^~~~~~~~
../../src/bin/eolian_mono/eolian_mono/parameter.hh:20:9: note:   template argument deduction/substitution failed:
In file included from ../../src/bin/eolian_mono/eolian_mono/klass.hh:8:0,
                 from ../../src/bin/eolian_mono/eolian_mono.cc:25:
../../src/lib/eolian_cxx/grammar/list.hpp:24:15: note:   cannot convert ‘c’ (type ‘const char’) to type ‘const efl::eolian::grammar::attributes::parameter_def&’
            if(!generator.generate(sink, c, context))
                
make[3]: *** [Makefile:47121: bin/eolian_mono/bin_eolian_mono_eolian_mono-eolian_mono.o] Error 1
make[2]: *** [Makefile:50657: check-recursive] Error 1
make[1]: *** [Makefile:51331: check] Error 2
make: *** [Makefile:2974: check-recursive] Error 1

bug#24821: Emacs 25.1.1

[npostavs]

Felipe Magno de Almeida <eu@felipemagno.com.br> writes:

> The attached content when displayed in compilation-mode causes emacs
> to crash in my machine.
>
> I use a arch linux distribution.
>
> It even crashes if I do M-x compilation-mode on the file itself,
> instead of running it through M-x compile. And it crashes every single
> time, so it is easily reproduceable.

Even so, it's helpful to post the information produced by M-x
report-emacs-bugs, in particular, if this is the bug I think it is,
the toolkit you configure with can affect the reproducibility.

Does it help to apply the following patches?

http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=9afea93ed536fb9110ac62b413604cf4c4302199
http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=71ca4f6a43bad06192cbc4bb8c7a2d69c179b7b0
http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=1047496722a58ef5b736dae64d32adeb58c5055c
http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=96ac0c3ebce825e60595794f99e703ec8302e240
http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=43986d16fb6ad78a627250e14570ea70bdb1f23a

Alternatively, try configuring with REL_ALLOC=no.

See also
https://lists.gnu.org/archive/html/emacs-devel/2016-10/msg00917.html
...
https://lists.gnu.org/archive/html/emacs-devel/2016-10/msg00971.html
https://debbugs.gnu.org/cgi/bugreport.cgi?bug=24358

bug#24821: Emacs 25.1.1

[Felipe Magno de Almeida]

On Sat, Oct 29, 2016 at 6:14 PM,  <npostavs@users.sourceforge.net> wrote:
> Felipe Magno de Almeida <eu@felipemagno.com.br> writes:
>
>> The attached content when displayed in compilation-mode causes emacs
>> to crash in my machine.
>>
>> I use a arch linux distribution.
>>
>> It even crashes if I do M-x compilation-mode on the file itself,
>> instead of running it through M-x compile. And it crashes every single
>> time, so it is easily reproduceable.
>
> Even so, it's helpful to post the information produced by M-x
> report-emacs-bugs, in particular, if this is the bug I think it is,
> the toolkit you configure with can affect the reproducibility.

Thanks, will do that next time.

> Does it help to apply the following patches?

Yes, I can't reproduce the problem anymore. Thanks.

> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=9afea93ed536fb9110ac62b413604cf4c4302199
> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=71ca4f6a43bad06192cbc4bb8c7a2d69c179b7b0
> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=1047496722a58ef5b736dae64d32adeb58c5055c
> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=96ac0c3ebce825e60595794f99e703ec8302e240
> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=43986d16fb6ad78a627250e14570ea70bdb1f23a
>
> Alternatively, try configuring with REL_ALLOC=no.
>
> See also
> https://lists.gnu.org/archive/html/emacs-devel/2016-10/msg00917.html
> ...
> https://lists.gnu.org/archive/html/emacs-devel/2016-10/msg00971.html
> https://debbugs.gnu.org/cgi/bugreport.cgi?bug=24358



-- 
Felipe Magno de Almeida

bug#24821: Emacs 25.1.1

[npostavs]

forcemerge 24358 24821
quit

>
>> Does it help to apply the following patches?
>
> Yes, I can't reproduce the problem anymore. Thanks.

Thanks for confirming.

>
>> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=9afea93ed536fb9110ac62b413604cf4c4302199
>> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=71ca4f6a43bad06192cbc4bb8c7a2d69c179b7b0
>> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=1047496722a58ef5b736dae64d32adeb58c5055c
>> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=96ac0c3ebce825e60595794f99e703ec8302e240
>> http://git.savannah.gnu.org/cgit/emacs.git/patch/?id=43986d16fb6ad78a627250e14570ea70bdb1f23a
>>
>> Alternatively, try configuring with REL_ALLOC=no.
>>
>> See also
>> https://lists.gnu.org/archive/html/emacs-devel/2016-10/msg00917.html
>> ...
>> https://lists.gnu.org/archive/html/emacs-devel/2016-10/msg00971.html
>> https://debbugs.gnu.org/cgi/bugreport.cgi?bug=24358