parse.hpp

Go to the documentation of this file.

/*
  PARSE.hpp  -  helpers for parsing textual specifications
 
   Copyright (C)
     2024,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_PARSE_H
#define LIB_PARSE_H
 
 
#include "lib/error.hpp"
#include "lib/branch-case.hpp"
#include "lib/format-string.hpp"
#include "lib/meta/variadic-rebind.hpp"
#include "lib/meta/function.hpp"
#include "lib/meta/trait.hpp"
#include "lib/regex.hpp"
 
#include <optional>
#include <utility>
#include <cstddef>
#include <tuple>
#include <array>
 
namespace util {
  namespace parse {
    namespace err = lumiera::error;
    
    using std::move;
    using std::forward;
    using std::optional;
    using lib::meta::_Fun;
    using lib::meta::has_Sig;
    using lib::meta::_Vari;
    using lib::meta::Nil;
    using std::decay_t;
    using std::tuple;
    using std::array;
    using util::_Fmt;
    
    using StrView = std::string_view;
    
    template<class PAR>
    class Syntax;
    
    template<class CON>
    class Parser;
    
    
    
    template<class RES>
    struct Eval
      {
        using Result = RES;
        optional<RES> result;
        size_t consumed{0};
      };
    
    template<class FUN>
    struct Connex
      {
        using PFun = FUN;
        PFun parse;
        
        using Result = _Fun<PFun>::Ret::Result;
        
        Connex (FUN pFun)
          : parse{pFun}
          { }
      };
    
    template<class RES>
    using OpaqueConnex = Connex<std::function<Eval<RES>(StrView)>>;
    
    template<class RES>
    using ForwardConnex = Connex<std::function<Eval<RES>(StrView)>&>;
    
    
    
    
    
    inline auto
    buildConnex(Nil)
    {
      return Connex{[](StrView) -> Eval<Nil>
                      {
                        return {Nil()};
                      }};
    }
    using NulP = decltype(buildConnex (Nil()));
    
    
    inline auto
    buildConnex (regex rex)
    {
      return Connex{[regEx = move(rex)]
                    (StrView toParse) -> Eval<smatch>
                      {           // skip leading whitespace...
                        size_t pre = leadingWhitespace (toParse);
                        toParse = toParse.substr(pre);
                        auto result{matchAtStart (toParse,regEx)};
                        size_t consumed = result? pre+result->length() : 0;
                        return {move(result), consumed};
                      }};
    }
    using Term = decltype(buildConnex (std::declval<regex>()));
    
    inline Term
    buildConnex (string const& rexDef)
    {
      return buildConnex (regex{rexDef});
    }
    
    template<class FUN>
    inline auto
    buildConnex (Connex<FUN> const& anchor)
    {
      return Connex{anchor};
    }
    template<class FUN>
    inline auto
    buildConnex (Connex<FUN> && anchor)
    {
      return Connex{move(anchor)};
    }
    
    template<class PAR>
    inline auto
    buildConnex (Syntax<PAR> const& anchor)
    {
      using Con = Syntax<PAR>::Connex;
      return Con{anchor};
    }
    
    template<class RES>
    inline auto
    buildConnex (Syntax<Parser<OpaqueConnex<RES>>> & refClause)
    {
      OpaqueConnex<RES>& refConnex = refClause;
      return ForwardConnex<RES>{refConnex.parse};
    }
    
    
    
    namespace {
      template<typename ARG, typename FUN, typename SEL =void>
      struct _ProbeFunReturn
        {
          static_assert (!sizeof(ARG),
                         "Model binding must accept preceding model result.");
        };
      
      template<typename ARG, typename FUN>
      struct _ProbeFunReturn<ARG,FUN, std::void_t<decltype(std::declval<FUN>() (std::declval<ARG>()))>>
        {                                       // probe the λ with ARG to force template instantiation
          using Ret = decltype(std::declval<FUN>() (std::declval<ARG>()));
        };
      
      
      template<class FUN>
      inline bool
      _boundFun(FUN const& fun)
      {
        if constexpr (std::is_constructible<bool, FUN const&>())
          return bool(fun);
        else
          return std::is_invocable<FUN, StrView>();
      }
    }
    
    template<class CON, class BIND>
    inline auto
    adaptConnex (CON&& connex, BIND&& modelBinding)
    {
      using RX = CON::Result;
      using Arg = std::add_rvalue_reference_t<RX>;
      using AdaptedRes = _ProbeFunReturn<Arg,BIND>::Ret;
      return Connex{[origConnex = forward<CON>(connex)
                    ,binding = forward<BIND>(modelBinding)
                    ]
                    (StrView toParse) -> Eval<AdaptedRes>
                      {
                        auto eval = origConnex.parse (toParse);
                        if (eval.result)
                          return {binding (move (*eval.result))
                                 ,eval.consumed};
                        else
                          return {std::nullopt};
                      }};
    }
    
    template<class CON>
    inline auto
    toStringConnex (CON&& connex, uint part)
    {
      using Result = CON::Result;
      return Connex([baseConnex = forward<CON>(connex)
                    ,part
                    ]
                    (StrView toParse) -> Eval<string>
                      {
                        auto eval = baseConnex.parse (toParse);
                        if (eval.result)
                          if constexpr (lib::meta::is_basically<Result,smatch>())
                              return {eval.result->str(part)
                                     ,eval.consumed
                                     };
                          else
                            { // defensive fall-back: ignore model, return accepted input part
                              size_t pre = leadingWhitespace (toParse);
                              return {string{toParse.substr (pre, eval.consumed - pre)}
                                     ,eval.consumed
                                     };
                            }
                        else
                          return {std::nullopt};
                      });
    }
    
    
    
    /* ===== building structured models ===== */
    
    template<typename...RESULTS>
    struct SeqModel
      : tuple<RESULTS...>
      {
        static constexpr size_t N = sizeof...(RESULTS);
        using Seq = lib::meta::Types<RESULTS...>;
        using Tup = std::tuple<RESULTS...>;
        
        SeqModel() = default;
        
        template<typename...XS, typename XX>
        SeqModel (SeqModel<XS...>&& seq, XX&& extraElm)
          : Tup{std::tuple_cat (seq.extractTuple()
                               ,std::make_tuple (forward<XX> (extraElm)) )}
          { }
          
        template<typename X1, typename X2>
        SeqModel (X1&& res1, X2&& res2)
          : Tup{move(res1), move(res2)}
          { }
        
        Tup&& extractTuple() { return move(*this); }
        
        template<size_t i>
        auto get() { return std::get<i> (*this); }
      };
    
    
    template<typename...CASES>
    struct AltModel
      : lib::BranchCase<CASES...>
      {
        using Alt = lib::BranchCase<CASES...>;
        static constexpr size_t N = sizeof...(CASES);
        
        template<typename EXTRA>
        using Additionally = AltModel<CASES...,EXTRA>;
        
        template<typename EXTRA>
        Additionally<EXTRA>
        addBranch()      
          {
            Additionally<EXTRA>& upFaked = reinterpret_cast<Additionally<EXTRA>&> (*this);
            return {move (upFaked)};
          }           // this trick works due to similar storage layout
        
        
        /* === Builder functions to mark which side of the combinator to pick === */
        
        using SubSeq = _Vari<AltModel, CASES...>::Prefix;  
        using Penult = _Vari<AltModel, CASES...>::Penult;  
        using Ultima = _Vari<AltModel, CASES...>::Ultima;  
        
        static AltModel
        mark_left (SubSeq&& leftCases)
          {
            return {leftCases.template addBranch<Ultima>()};
          }
        
        static AltModel
        mark_left (Penult&& leftCase)
          {
            return {Alt::TOP-1, move(leftCase)};
          }
        
        static AltModel
        mark_right (Ultima&& rightCase)
          {
            return {Alt::TOP, move(rightCase)};
          }
        
      private:
        template<typename INIT>
        AltModel (size_t branchID, INIT&& init)
          : Alt{branchID, forward<INIT> (init)}
          { }
      };
    
    
    template<typename RES>
    struct IterModel
      : std::vector<RES>
      {
        RES& get (size_t i) { return this->at(i); }
      };
    
    template<typename RES>
    struct SubModel
      { /* for metaprogramming only */ };
    
    
    template<template<class...> class TAG, class R1, class R2 =void>
    struct _Join
      {
        using Result = TAG<R1,R2>;
      };
    
    template<template<class...> class TAG, class...RS, class R2>
    struct _Join<TAG,TAG<RS...>,R2>
      {
        using Result = TAG<RS...,R2>;
      };
    
    template<template<class...> class TAG, class R1, class R2>
    struct _Join<TAG,SubModel<R1>,R2>
      {
        using Result = TAG<R1,R2>;
      };
    template<template<class...> class TAG, class R1, class R2>
    struct _Join<TAG,R1, SubModel<R2>>
      {
        using Result = TAG<R1,R2>;
      };
    template<template<class...> class TAG, class R1, class R2>
    struct _Join<TAG,SubModel<R1>,SubModel<R2>>
      {
        using Result = TAG<R1,R2>;
      };
    
    
    
    template<class C1, class C2>
    inline auto
    sequenceConnex (C1&& connex1, C2&& connex2)
    {
      using R1 = decay_t<C1>::Result;
      using R2 = decay_t<C2>::Result;
      using ProductResult =  _Join<SeqModel, R1, R2>::Result;
      using ProductEval = Eval<ProductResult>;
      return Connex{[conL = forward<C1>(connex1)
                    ,conR = forward<C2>(connex2)
                    ]
                    (StrView toParse) -> ProductEval
                      {
                        auto eval1 = conL.parse (toParse);
                        if (eval1.result)
                          {
                            size_t posAfter1 = eval1.consumed;
                            StrView restInput = toParse.substr(posAfter1);
                            auto eval2 = conR.parse (restInput);
                            if (eval2.result)
                              {
                                uint consumedOverall = posAfter1 + eval2.consumed;
                                return ProductEval{ProductResult{move(*eval1.result)
                                                                ,move(*eval2.result)}
                                                  ,consumedOverall
                                                  };
                              }
                          }
                        return ProductEval{std::nullopt};
                      }};
    }
    
    
    template<class C1, class C2>
    inline auto
    branchedConnex (C1&& connex1, C2&& connex2)
    {
      using R1 = decay_t<C1>::Result;
      using R2 = decay_t<C2>::Result;
      using SumResult = _Join<AltModel, R1, R2>::Result;
      using SumEval = Eval<SumResult>;
      return Connex{[conL = forward<C1>(connex1)
                    ,conR = forward<C2>(connex2)
                    ]
                    (StrView toParse) -> SumEval
                      {
                        auto eval1 = conL.parse (toParse);
                        if (eval1.result)
                          {
                            uint endBranch1 = eval1.consumed;
                            return SumEval{SumResult::mark_left (move(*eval1.result))
                                          ,endBranch1
                                          };
                          }
                        auto eval2 = conR.parse (toParse);
                        if (eval2.result)
                          {
                            uint endBranch2 = eval2.consumed;
                            return SumEval{SumResult::mark_right (move(*eval2.result))
                                          ,endBranch2
                                          };
                          }
                        return SumEval{std::nullopt};
                      }};
    }
    
    
    template<class C1, class C2>
    inline auto
    repeatedConnex (uint min, uint max
                   ,C1&& delimConnex
                   ,C2&& bodyConnex)
    {
      using Res = decay_t<C2>::Result;
      using IterResult = IterModel<Res>;
      using IterEval = Eval<IterResult>;
      return Connex{[sep = forward<C1>(delimConnex)
                    ,body = forward<C2>(bodyConnex)
                    ,min,max
                    ]
                    (StrView toParse) -> IterEval
                      {
                        size_t consumed{0};
                        IterResult results;
                        do
                          {
                            uint offset{0};
                            if (not results.empty())
                              {  // look for delimiter within sequence
                                auto delim = sep.parse (toParse);
                                if (not delim.result)
                                  break;
                                offset += delim.consumed;
                              }
                            auto eval = body.parse (toParse.substr(offset));
                            if (not eval.result)
                              break;
                            offset += eval.consumed;
                            results.emplace_back (move(*eval.result));
                            toParse = toParse.substr(offset);
                            consumed += offset;
                          }
                        while (results.size() < max);
                        return results.size() >= min? IterEval{move(results), consumed}
                                                    : IterEval{std::nullopt};
                      }};
    }
    
    
    template<class CNX>
    inline auto
    optionalConnex (CNX&& connex)
    {
      using Res = decay_t<CNX>::Result;
      using OptResult = optional<Res>;
      using OptEval = Eval<OptResult>;
      return Connex{[body = forward<CNX>(connex)
                    ]
                    (StrView toParse) -> OptEval
                      {
                        auto eval = body.parse (toParse);
                        size_t consumed{eval.result? eval.consumed : 0};
                        return OptEval{OptResult{eval.result? move(eval.result) : std::nullopt}
                                      ,consumed
                                      };
                      }};
    }
    
    
    template<class C1, class C2, class C3>
    inline auto
    bracketedConnex (C1&& openingConnex
                    ,C2&& closingConnex
                    ,C3&& bodyConnex
                    ,bool isOptional)
    {
      using Res = decay_t<C3>::Result;
      return Connex{[opening = forward<C1>(openingConnex)
                    ,closing = forward<C2>(closingConnex)
                    ,body    = forward<C3>(bodyConnex)
                    ,isOptional
                    ]
                    (StrView toParse) -> Eval<Res>
                      {
                        auto bracket = opening.parse (toParse);
                        if (bracket.result or isOptional)
                          {
                            size_t consumed = bracket.consumed;
                            bool expectClose{bracket.result};
                            auto eval = body.parse (toParse.substr(consumed));
                            if (eval.result)
                              {
                                consumed += eval.consumed;
                                if (expectClose)
                                  bracket = closing.parse (toParse.substr(consumed));
                                if (bracket.result or not expectClose)
                                  {
                                    consumed += bracket.consumed;
                                    return Eval<Res>{move (*eval.result)
                                                    ,consumed
                                                    };
                                  }
                              }
                          }
                        return Eval<Res>{std::nullopt};
                      }};
    }
    
    
    
    
    template<class CON>
    class Parser
      : public CON
      {
        using PFun = CON::PFun;
        static_assert (_Fun<PFun>(), "Connex must define a parse-function");
        
      public:
        using Connex = CON;
        using Result = CON::Result;
        
        static_assert (has_Sig<PFun, Eval<Result>(StrView)>()
                      ,"Signature of the parse-function not suitable");
        
        Eval<Result>
        operator() (StrView toParse)
          {
            REQUIRE (_boundFun (CON::parse), "unbound recursive syntax");
            return CON::parse (toParse);
          }
        
        template<typename SPEC>
        Parser (SPEC&& spec)
          : CON{buildConnex (forward<SPEC> (spec))}
          { }
      };
    
    /* === Deduction guide : how to construct a Parser === */
    Parser(Nil)           -> Parser<NulP>;
    Parser(regex &&)      -> Parser<Term>;
    Parser(regex const&)  -> Parser<Term>;
    Parser(string const&) -> Parser<Term>;
    
    template<class FUN>
    Parser(Connex<FUN>) -> Parser<Connex<FUN>>;
    
    template<class PAR>
    Parser(Syntax<PAR>) -> Parser<typename PAR::Connex>;
    
    template<class RES>
    Parser(Syntax<Parser<OpaqueConnex<RES>>>) -> Parser<ForwardConnex<RES>>;
                                              // bind to recursive syntax by reference
    
    
    template<typename SPEC, typename SEL =void>
    struct is_usableSpec : std::false_type{ };
    
    template<typename SPEC>
    struct is_usableSpec<SPEC, std::void_t<decltype(Parser{std::declval<SPEC>()})>>
      : std::true_type
      { };
    
    template<typename SPEC>
    using if_acceptableSpec  = lib::meta::enable_if<is_usableSpec<SPEC>>;
    
    template<typename SPEC1, typename SPEC2>
    using if_acceptableSpecs = lib::meta::enable_if<is_usableSpec<SPEC1>
                                                   ,lib::meta::enable_if<is_usableSpec<SPEC2>>>;
    
    
    
    
    /***********************************************************************/
    template<class PAR>
    class Syntax
      : public Eval<typename PAR::Result>
      {
        PAR parse_;
        
      public:
        using Connex = PAR::Connex;
        using Result = PAR::Result;
        
        Syntax()
          : parse_{Nil()}
          { }
        
        explicit
        Syntax (PAR&& parser)
          : parse_{move (parser)}
          { }
        
        explicit
        operator bool()          const { return success();}
        
        operator Connex&()             { return parse_; }
        operator Connex const&() const { return parse_; }
        
        bool success()           const { return bool(Syntax::result);   }
        bool hasResult()         const { return bool(Syntax::result);   }
        bool canInvoke()         const { return _boundFun(parse_.parse);}
        size_t consumed()        const { return Eval<Result>::consumed; }
        Result& getResult()            { return * Syntax::result;       }
        Result&& extractResult()       { return move(getResult());      }
        
        
        /********************************************/
        Syntax&&
        parse (StrView toParse)
          {
            eval() = parse_(toParse);
            return move(*this);
          }
        
        
        template<class PX>
        Syntax&
        operator= (Syntax<PX> refSyntax)
          {
            using ConX = PX::Connex;
            ConX& refConnex = refSyntax;
            parse_.parse = move(refConnex.parse);
            return *this;
          }
        
        
        template<typename SPEC>
        auto seq (SPEC&& clauseDef);
        
        template<typename SPEC>
        auto alt (SPEC&& clauseDef);
        
        template<typename SPEC>
        auto opt (SPEC&& clauseDef);
        
        template<typename SPEC1, typename SPEC2>
        auto repeat (uint min, uint max, SPEC1&& delimDef, SPEC2&& clauseDef);
        
        template<typename SPEC1, typename SPEC2>
        auto repeat (uint cnt, SPEC1&& delimDef, SPEC2&& clauseDef);
        
        template<typename SPEC1, typename SPEC2>
        auto repeat (SPEC1&& delimDef, SPEC2&& clauseDef);
        
        template<typename SPEC>
        auto repeat (SPEC&& clauseDef);
        
        template<typename SPEC1, typename SPEC2, typename SPEC3>
        auto bracket (SPEC1&& openDef, SPEC2&& closeDef, SPEC3&& bodyDef);
        
        template<typename SPEC>
        auto bracket (string bracketSpec, SPEC&& bodyDef);
        
        template<typename SPEC>
        auto bracket (SPEC&& bodyDef);
        
        template<typename SPEC>
        auto bracketOpt (string bracketSpec, SPEC&& bodyDef);
        
        template<typename SPEC>
        auto bracketOpt (SPEC&& bodyDef);
        
        template<class FUN>
        auto bind (FUN&& modelAdapt);
        
        auto bindMatch (uint group =0);
        
      private:
        Eval<Result>& eval() { return *this;}
      };
    
    
    
    
    template<typename SPEC>
    inline auto
    accept (SPEC&& clauseDef)
    {
      return Syntax{Parser{forward<SPEC> (clauseDef)}};
    }
    
    inline auto accept() { return Syntax<Parser<NulP>>{}; }
    
    
    template<typename SPEC>
    inline auto
    accept_opt (SPEC&& clauseDef)
    {
      return accept(
              optionalConnex (Parser{forward<SPEC> (clauseDef)}));
    }
    
    
    template<typename SPEC1, typename SPEC2>
    inline auto
    accept_repeated (uint min, uint max, SPEC1&& delimDef, SPEC2&& clauseDef)
      {
        if (max<min)
          throw err::Invalid{_Fmt{"Invalid repeated syntax-spec: min:%d > max:%d"}
                                                               % min    % max    };
        if (max == 0)
          throw err::Invalid{"Invalid repeat with max ≡ 0 repetitions"};
        
        return accept(
                repeatedConnex (min,max
                               ,Parser{forward<SPEC1> (delimDef)}
                               ,Parser{forward<SPEC2> (clauseDef)}));
      }
 
    template<typename SPEC1, typename SPEC2,                                       typename =if_acceptableSpecs<SPEC1,SPEC2>>
    inline auto
    accept_repeated (uint cnt, SPEC1&& delimDef, SPEC2&& clauseDef)
      {
        return accept_repeated (cnt,cnt, forward<SPEC1>(delimDef), forward<SPEC2>(clauseDef));
      }
    
    template<typename SPEC1, typename SPEC2,                                       typename =if_acceptableSpecs<SPEC1,SPEC2>>
    inline auto
    accept_repeated (SPEC1&& delimDef, SPEC2&& clauseDef)
      {
        return accept_repeated (1,uint(-1), forward<SPEC1>(delimDef), forward<SPEC2>(clauseDef));
      }
    
    template<typename SPEC>
    inline auto
    accept_repeated (uint min, uint max, SPEC&& clauseDef)
      {
        return accept_repeated (min, max, Nil{}, forward<SPEC>(clauseDef));
      }
    
    template<typename SPEC>
    inline auto
    accept_repeated (uint cnt, SPEC&& clauseDef)
      {
        return accept_repeated (cnt, Nil{}, forward<SPEC>(clauseDef));
      }
    
    template<typename SPEC>
    inline auto
    accept_repeated (SPEC&& clauseDef)
      {
        return accept_repeated (Nil{}, forward<SPEC>(clauseDef));
      }
    
    template<typename SPEC1, typename SPEC2, typename SPEC3>
    inline auto
    accept_bracket (SPEC1&& openDef, SPEC2&& closeDef, SPEC3&& bodyDef)
      {
        return accept(
                 bracketedConnex (Parser{forward<SPEC1>(openDef) }
                                 ,Parser{forward<SPEC2>(closeDef)}
                                 ,Parser{forward<SPEC3>(bodyDef) }
                                 ,false // bracket mandatory, not optional
                                 ));
      }
    
    template<typename SPEC>
    inline auto
    accept_bracket (string bracketSpec, SPEC&& bodyDef)
      {
        if (bracketSpec.size() != 2)
          throw err::Invalid{"Bracket spec with opening and closing character expected"};
        return accept(
                 bracketedConnex (Parser{"\\"+bracketSpec.substr(0,1)}
                                 ,Parser{"\\"+bracketSpec.substr(1,1)}
                                 ,Parser{forward<SPEC>(bodyDef) }
                                 ,false // bracket mandatory, not optional
                                 ));
      }
    
    template<typename SPEC>
    inline auto
    accept_bracket (SPEC&& bodyDef)
      {
        return accept_bracket ("()", forward<SPEC>(bodyDef));
      }
    
    template<typename SPEC>
    inline auto
    accept_bracketOpt (string bracketSpec, SPEC&& bodyDef)
      {
        if (bracketSpec.size() != 2)
          throw err::Invalid{"Bracket spec with opening and closing character expected"};
        return accept(
                 bracketedConnex (Parser{"\\"+bracketSpec.substr(0,1)}
                                 ,Parser{"\\"+bracketSpec.substr(1,1)}
                                 ,Parser{forward<SPEC>(bodyDef) }
                                 ,true // bracket optional, can be omitted
                                 ));
      }
    
    template<typename SPEC>
    inline auto
    accept_bracketOpt (SPEC&& bodyDef)
      {
        return accept_bracketOpt ("()", forward<SPEC>(bodyDef));
      }
    
    
    template<typename RES>
    inline auto
    expectResult()
      {
        return accept (Connex{std::function<Eval<RES>(StrView)>{}});
      }
    
    
    
    template<class PAR>
    template<typename SPEC>
    inline auto
    Syntax<PAR>::seq (SPEC&& clauseDef)
      {
        return accept(
                sequenceConnex (move(parse_)
                               ,Parser{forward<SPEC> (clauseDef)}));
      }
    
    template<class PAR>
    template<typename SPEC>
    inline auto
    Syntax<PAR>::alt (SPEC&& clauseDef)
      {
        return accept(
                branchedConnex (move(parse_)
                               ,Parser{forward<SPEC> (clauseDef)}));
      }
    
    template<class PAR>
    template<typename SPEC>
    inline auto
    Syntax<PAR>::opt (SPEC&& clauseDef)
      {
        return seq (accept_opt (forward<SPEC> (clauseDef)));
      }
    
    template<class PAR>
    template<typename SPEC1, typename SPEC2>
    inline auto
    Syntax<PAR>::repeat (uint min, uint max, SPEC1&& delimDef, SPEC2&& clauseDef)
      {
        return seq (accept_repeated (min,max
                                    ,forward<SPEC1>(clauseDef)
                                    ,forward<SPEC2>(clauseDef)));
      }
    
    template<class PAR>
    template<typename SPEC1, typename SPEC2>
    inline auto
    Syntax<PAR>::repeat (uint cnt, SPEC1&& delimDef, SPEC2&& clauseDef)
      {
        return seq (accept_repeated (cnt
                                    ,forward<SPEC1>(clauseDef)
                                    ,forward<SPEC2>(clauseDef)));
      }
    
    template<class PAR>
    template<typename SPEC1, typename SPEC2>
    inline auto
    Syntax<PAR>::repeat (SPEC1&& delimDef, SPEC2&& clauseDef)
      {
        return seq (accept_repeated (forward<SPEC1>(clauseDef)
                                    ,forward<SPEC2>(clauseDef)));
      }
    
    template<class PAR>
    template<typename SPEC>
    inline auto
    Syntax<PAR>::repeat (SPEC&& clauseDef)
      {
        return seq (accept_repeated (forward<SPEC>(clauseDef)));
      }
    
    template<class PAR>
    template<typename SPEC1, typename SPEC2, typename SPEC3>
    inline auto
    Syntax<PAR>::bracket (SPEC1&& openDef, SPEC2&& closeDef, SPEC3&& bodyDef)
      {
        return seq (accept_bracket (forward<SPEC1>(openDef)
                                   ,forward<SPEC2>(closeDef)
                                   ,forward<SPEC3>(bodyDef)));
      }
    
    template<class PAR>
    template<typename SPEC>
    inline auto
    Syntax<PAR>::bracket (string bracketSpec, SPEC&& bodyDef)
      {
        return seq (accept_bracket (move (bracketSpec)
                                   ,forward<SPEC>(bodyDef)));
      }
    
    template<class PAR>
    template<typename SPEC>
    inline auto
    Syntax<PAR>::bracket (SPEC&& bodyDef)
      {
        return seq (accept_bracket (forward<SPEC>(bodyDef)));
      }
    
    template<class PAR>
    template<typename SPEC>
    inline auto
    Syntax<PAR>::bracketOpt (string bracketSpec, SPEC&& bodyDef)
      {
        return seq (accept_bracketOpt (move (bracketSpec)
                                      ,forward<SPEC>(bodyDef)));
      }
    
    template<class PAR>
    template<typename SPEC>
    inline auto
    Syntax<PAR>::bracketOpt (SPEC&& bodyDef)
      {
        return seq (accept_bracketOpt (forward<SPEC>(bodyDef)));
      }
    
    template<class PAR>
    template<class FUN>
    inline auto
    Syntax<PAR>::bind (FUN&& modelAdapt)
      {
        return accept(
                 adaptConnex (move(parse_)
                             ,forward<FUN>(modelAdapt)));
      }
    
    template<class PAR>
    inline auto
    Syntax<PAR>::bindMatch (uint group)
      {
        return accept(
                 toStringConnex (move(parse_), group));
      }
    
  }// namespace parse
  
  
  using parse::accept;
  using parse::accept_opt;
  using parse::accept_repeated;
  using parse::accept_bracket;
  
}// namespace util
 
 
namespace std { // Specialisation to support C++ »Tuple Protocol« and structured bindings.
  
  template<typename...ELMS>
  struct tuple_size<util::parse::SeqModel<ELMS...> >
    : tuple_size<typename util::parse::SeqModel<ELMS...>::Tup >
    { };
 
  template<size_t I, typename...ELMS>
  struct tuple_element<I, util::parse::SeqModel<ELMS...> >
    : tuple_element<I, typename util::parse::SeqModel<ELMS...>::Tup >
    { };
}
#endif/*LIB_PARSE_H*/