--
--
--
is_predicate<>;   Ct / Pred

scc '__ v9/[](int i){return i==2;} - +v9;'
2
--
class-ol implemented
debug.h,  type2name
new is_callable -- check args, but not return type

                           is  has  is  is      is      is          is  is  is  is  is  is
                           CT  cns  IT inpt    Queue    F  is  is  Ptr Ref  MF  FN PREDPRED
                               IT       IT  is      is     F    F          Ptr     ICATICAT is  is
                                           Stack    IO-    rm  rm                  E   E   CALLCALL
                                                   able    P   Ref                      c&      c&
               vector<int>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
     set<int,greater<int>>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
     vector<int>::iterator  ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
      deque<int>::iterator  ∙   +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
       ostream_it<int>::it  ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
       istream_it<int>::it  ∙   ∙   +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                  set<int>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          map<string, int>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          pair<string,int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
         tuple<string,int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                queue<int>  ∙   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
       priority_queue<int>  ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                stack<int>  ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                    string  +   +   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                       fld  ∙   +   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
      basic_string<T,....>  +   +   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          string::iterator  ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                    int[5]  +   ∙   +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                   char[5]  +   ∙   +   +   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
             const char[5]  +   ∙   +   +   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
               const char*  ∙   ∙   +   +   ∙   ∙   +   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                      int*  ∙   ∙   +   +   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                    struct  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙

               bool T(int)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   ∙   +   +
               int* T(int)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   ∙   +   +
        bool T(const int&)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   ∙   +   +
                  bool T()  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙
            bool (*T)(int)  ∙   ∙   +   +   ∙   ∙   ∙   ∙   +   ∙   +   ∙   ∙   +   ∙   ∙   +   +
               decltype(f)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   ∙   +   +
           decltype(::sin)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   ∙   +   +
                      fo_t  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   +
  std::function<bool(int)>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   +   +
     std::function<bool()>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙
  std::function<bool(*)()>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙
                     lam_t  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   +
      std::function<lam_t>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          std::negate<int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   +
            std::less<int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   ∙   ∙
added basic metafunctions
is_callable4<F,R,Arg> -- todo Arg...

                           is  has  is  is      is      is          is  is  is  is  is
                           CT  cns  IT inpt    Queue    F  is  is  Ptr Ref  MF  FN PRED
                               IT       IT  is      is     F    F          Ptr     ICAT is  is  is
                                           Stack    IO-    rm  rm                  E   CALL 3   4
                                                   able    P   Ref

               bool T(int)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   +   +   +
               int* T(int)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   +   +   ∙
        bool T(const int&)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   +   +   +
                  bool T()  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙
            bool (*T)(int)  ∙   ∙   +   +   ∙   ∙   ∙   ∙   +   ∙   +   ∙   ∙   +   ∙   +   +   +
               decltype(f)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   +   +   +
           decltype(::sin)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙   ∙   ∙   +   ∙   +   +   ∙
                      fo_t  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   +
  std::function<bool(int)>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   +   +
     std::function<bool()>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   ∙   ∙   ∙
  std::function<bool(*)()>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙
                     lam_t  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   +
      std::function<lam_t>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          std::negate<int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   +   +   ∙
            std::less<int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙
is_callable1,2<>

                           is  has  is  is      is      is
                           CT  cns  IT inpt    Queue   call
                               IT       IT  is      is  1   is
                                           Stack    IO-    call
                                                   able     2
               vector<int>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
     set<int,greater<int>>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
     vector<int>::iterator  ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙
      deque<int>::iterator  ∙   +   +   ∙   ∙   ∙   ∙   ∙   ∙
       ostream_it<int>::it  ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙
       istream_it<int>::it  ∙   ∙   +   +   ∙   ∙   ∙   ∙   ∙
                  set<int>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          map<string, int>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          pair<string,int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
         tuple<string,int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                queue<int>  ∙   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙
       priority_queue<int>  ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙
                stack<int>  ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙
                    string  +   +   ∙   ∙   ∙   ∙   +   ∙   ∙
                       fld  ∙   +   ∙   ∙   ∙   ∙   +   ∙   ∙
      basic_string<T,....>  +   +   ∙   ∙   ∙   ∙   +   ∙   ∙
          string::iterator  ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙
                    int[5]  +   ∙   +   +   ∙   ∙   ∙   ∙   ∙
                   char[5]  +   ∙   +   +   ∙   ∙   +   ∙   ∙
             const char[5]  +   ∙   +   +   ∙   ∙   +   ∙   ∙
               const char*  ∙   ∙   +   +   ∙   ∙   +   ∙   ∙
                      int*  ∙   ∙   +   +   ∙   ∙   ∙   ∙   ∙
                    struct  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙

               bool T(int)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
               int* T(int)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
        bool T(const int&)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
                  bool T()  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
            bool (*T)(int)  ∙   ∙   +   +   ∙   ∙   ∙   +   ∙
               decltype(f)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
           decltype(::sin)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                      fo_t  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
  std::function<bool(int)>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
     std::function<bool()>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
  std::function<bool(*)()>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                     lam_t  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
      std::function<lam_t>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          std::negate<int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
            std::less<int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +
fixed: is_iterator

                           is  has  is  is      is      is
                           CT  cns  IT inpt    Queue   call
                               IT       IT  is      is  1   is
                                           Stack    IO-    call
                                                   able     2
               vector<int>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
     set<int,greater<int>>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
     vector<int>::iterator  ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙
      deque<int>::iterator  ∙   +   +   ∙   ∙   ∙   ∙   ∙   ∙
       ostream_it<int>::it  ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙
       istream_it<int>::it  ∙   ∙   +   +   ∙   ∙   ∙   ∙   ∙
                  set<int>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          map<string, int>  +   +   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          pair<string,int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
         tuple<string,int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                queue<int>  ∙   ∙   ∙   ∙   ∙   +   ∙   ∙   ∙
       priority_queue<int>  ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙
                stack<int>  ∙   ∙   ∙   ∙   +   ∙   ∙   ∙   ∙
                    string  +   +   ∙   ∙   ∙   ∙   +   ∙   ∙
                       fld  ∙   +   ∙   ∙   ∙   ∙   +   ∙   ∙
      basic_string<T,....>  +   +   ∙   ∙   ∙   ∙   +   ∙   ∙
          string::iterator  ∙   ∙   +   ∙   ∙   ∙   ∙   ∙   ∙
                    int[5]  +   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                   char[5]  +   ∙   ∙   ∙   ∙   ∙   +   ∙   ∙
             const char[5]  +   ∙   ∙   ∙   ∙   ∙   +   ∙   ∙
               const char*  ∙   ∙   ∙   ∙   ∙   ∙   +   ∙   ∙
                      int*  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                    struct  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙

               bool T(int)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
               int* T(int)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
        bool T(const int&)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
                  bool T()  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
            bool (*T)(int)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
               bool (&T)()  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
               decltype(f)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
           decltype(::sin)  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                      fo_t  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
  std::function<bool(int)>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
     std::function<bool()>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
  std::function<bool(*)()>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
                     lam_t  ∙   ∙   ∙   ∙   ∙   ∙   ∙   +   ∙
      std::function<lam_t>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
          std::negate<int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙
            std::less<int>  ∙   ∙   ∙   ∙   ∙   ∙   ∙   ∙   +