Hi Yuriy,

I played around with compile-lambda-a.cpp and added a new function whose purpose is to replace every string in any lambda term with "foobar". This makes use of a nested Match {...} EndMatch construct. The full version of this file is available at a gist that I uploaded.

The relevant parts are given here:

void change_vars(Term& t) {
    var<Var&>  v;
    var<Term&> t1, t2;
    var<std::string> s;

    Match(t)
    {
        Case(C<Var>(s)) { return; }
        Case(C<Abs>(&v,&t1)) {
            ((Var &) v).name = std::string("foobar");

            // "Match(t1) {" instead of the line below
            // produces a SIGSEGV. Why is that?
            Match((Term &) t1){
                Case(C<Var>(v)) {
                    ((Var &) v).name = std::string("foobar");
                    return;
                }
                Otherwise() { return; }
            } EndMatch

            change_vars(t1);
            return ;
        }
        Case(C<App>(&t1,&t2)) {
            change_vars(t1);
            change_vars(t2);
            return ;
        }
    }
    EndMatch

    return;
}

I know by now, that the instanciation of the var template produces structs with appropriately overloaded conversion operators. But in the context of the Match statement unambiguous type deduction should not be working and thus the compiler should produce an error when it encountered Match(t1){ (see comment in above code block). But that does not happen.

With Match(t1) instead of the correct Match((Term &) t1) the code compiles, but quickly produces a SIGSEGV. Why does it even compile?

Best regards Florian

Although I try hard, I cannot figure out how I can use Mach7 to switch on a mutable variant in order to mutate its contents. The following is how I solve my problem in a 'traditional' way:

struct M{ char im = 0; };
struct N{ char in = 0; };
typedef boost::variant<M, N> VM;

void visit(VM& vm)
{
  if(M* m = boost::get<M>(&vm))
    m->im = 'm';
  else if (N* n = boost::get<N>(&vm))
    n->in = 'n';
}

How am I suppose to do the same with Mach7? I was only able to come up with this:

void visit7(VM& vm)
{
  mch::var<M&> m;
  mch::var<N&> n;

  Match(vm)
  {
    Case(mch::C<M>(m))
    {
      M* mp = m.m_value;
      mp->im = 'm';
    }
    Case(mch::C<N>(n))
    {
      N* np = n.m_value;
      np->in = 'n';
    }
  }
  EndMatch
}

But I suppose there must be a better way. Can you show me how it is intended to be used?

This is a it safer alternative to https://github.com/solodon4/Mach7/pull/46. It only works for T*, std::unique_ptr<T> and std::shared_ptr<T>. And it can be extended by users by means of specializing the new trait.

This occurs with both CMake and the Bakefile system I'm working on:

[6/172] Linking CXX executable unit/example01
FAILED: : && /home/ryan/stuff/Downloads/clang+llvm-3.6.0-x86_64-linux-gnu/bin/clang++   -fcolor-diagnostics   unit/CMakeFiles/example01.dir/example01.cpp.o  -o unit/example01  -rdynamic && :
unit/CMakeFiles/example01.dir/example01.cpp.o: In function `mch::vtblmap<mch::type_switch_info>::get(void const*)':
../unit/example01.cpp:(.text._ZN3mch7vtblmapINS_16type_switch_infoEE3getEPKv[_ZN3mch7vtblmapINS_16type_switch_infoEE3getEPKv]+0xd3): undefined reference to `mch::vtblmap<mch::type_switch_info>::update(long)'
clang: error: linker command failed with exit code 1 (use -v to see invocation)

This happens when linking pretty much any of the tests.

The current implementation of vtblmap4.hpp initialises and assumes vtbl indexes are not 0. The boost adaptor may return a vtbl index of 0 when storing the first type of the variant.

1. https://github.com/solodon4/Mach7/blob/40f062d21d721e251ba15c5e8e99068129a6bacf/code/mach7/vtblmap4.hpp#L253
2. https://github.com/solodon4/Mach7/blob/40f062d21d721e251ba15c5e8e99068129a6bacf/code/mach7/vtblmap4.hpp#L264
3. https://github.com/solodon4/Mach7/blob/40f062d21d721e251ba15c5e8e99068129a6bacf/code/mach7/vtblmap4.hpp#L270
4. https://github.com/solodon4/Mach7/blob/40f062d21d721e251ba15c5e8e99068129a6bacf/code/mach7/adapters/boost/adapt_boost_variant.hpp#L62

This results in an error when first matching against an index 0 and then having a collision. Which will reuse the cache-entry with a dirty switch_info.

I see three fixes:

1. Boost adaptor: change code to p->which() + 1;
2. Initialize cache entries with -1 value instead of 0. (or use some value outside the 48-bit pointer range)
3. Add a dirty flag to the cache entry to test isOccupied correctly.

I think option 2 is the best if possible. Option 1 keeps the bug around for other adaptors. Option 3 has a clear overhead.

Minimal example and pull request follow.

I can't build and execute unit tests on Red Hat Linux using make.

Top-level Makefile contains like:

# Create a list of source files.
SOURCES  = $(shell ls *.cpp)

But ls *.cpp is not a valid bash command, and I get an error. You probably meant either find -name *.cpp or find -maxdepth 1 -name *.cpp, but I do not know which one.

If I fix this, and then run make test, I get a bash error:

basename: extra operand `comp.clang.hpp'
Try `basename --help' for more information.
======================================== [ *.exe ]
/bin/sh: line 17: ./*.exe: No such file or directory

The reason travis ci cannot pass is that xcode develop toolchain is not installed by default.

this pr use osx_image: xcode10, which has installed xcode.

https://travis-ci.org/FirstLoveLife/Mach7/builds/502937900

I am getting the following error while doing cmake --build . :

In file included from /home/mnciitbhu/Git_Clones/Mach7/code/test/unit/algebraic.cpp:45:0:
/home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../match.hpp:946:9: note: #pragma message: Default pattern matching syntax is: G
   XTL_MESSAGE("Default pattern matching syntax is: G")
         ^
In file included from /home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../patterns/../metatools.hpp:47:0,
                 from /home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../patterns/bindings.hpp:48,
                 from /home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../unisyn.hpp:49,
                 from /home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../match.hpp:111,
                 from /home/mnciitbhu/Git_Clones/Mach7/code/test/unit/algebraic.cpp:45:
/home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../patterns/primitive.hpp:470:82: error: invalid use of ‘this’ at top level
     template <typename T> bool operator()(T&& t) const noexcept_when(noexcept_of(this->m_pat(std::forward<T>(t)))) { return m_pat(std::forward<T>(t)
                                                                                  ^
/home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../patterns/../config.hpp:345:37: note: in definition of macro ‘noexcept_when’
 #define noexcept_when(...) noexcept(__VA_ARGS__)
                                     ^
/home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../patterns/primitive.hpp:470:70: note: in expansion of macro ‘noexcept_of’
     template <typename T> bool operator()(T&& t) const noexcept_when(noexcept_of(this->m_pat(std::forward<T>(t)))) { return m_pat(std::forward<T>(t)
                                                                      ^
/home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../patterns/primitive.hpp:491:72: error: invalid use of ‘this’ at top level
     operator const result_type&() const noexcept_when(noexcept_of(eval(this->m_pat))) { return eval(this->m_pat); } // FIX: avoid implicit conversio
                                                                        ^
/home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../patterns/../config.hpp:345:37: note: in definition of macro ‘noexcept_when’
 #define noexcept_when(...) noexcept(__VA_ARGS__)
                                     ^
/home/mnciitbhu/Git_Clones/Mach7/code/test/unit/../../patterns/primitive.hpp:491:55: note: in expansion of macro ‘noexcept_of’
     operator const result_type&() const noexcept_when(noexcept_of(eval(this->m_pat))) { return eval(this->m_pat); } // FIX: avoid implicit conversio
                                                       ^
unit/CMakeFiles/algebraic.dir/build.make:54: recipe for target 'unit/CMakeFiles/algebraic.dir/algebraic.cpp.o' failed
make[2]: *** [unit/CMakeFiles/algebraic.dir/algebraic.cpp.o] Error 1
CMakeFiles/Makefile2:143: recipe for target 'unit/CMakeFiles/algebraic.dir/all' failed
make[1]: *** [unit/CMakeFiles/algebraic.dir/all] Error 2
Makefile:75: recipe for target 'all' failed
make: *** [all] Error 2

Am I missing anything?

I tested that the library for the support of boost::variant, and the simple example works fine, after I defined all the template specializations as per your example. However, I somehow got the expectation that I should be able to use the switch with two variants, like this:

void test(variant<X, Y, Z> vx, variant<M, N> vm)
{
    var<X> x; var<Y> y; var<Z> z;
    var<M> m; var<N> n;

    Match(vx, vm)
    {
        Case(C<X>(x), C<M>(m)) use(x, m);
        Case(C<Y>(y), C<M>(m)) use(y, m);
        // etc.
    }
    EndMatch
}

This fails to compile with classical meta-programming errors, but before I analyze them in detail, I wanted to check with you if my use case is even supposed to work?

Is Mach7 intended to switch on multiple heterogeneous types? Or is it just a bug in the implementation? Or perhaps my bug?

I have several different functions using Match/Case on the same type hierarchy, but which accept references to certain subgraphs of that hierarchy. I noticed that some Cases were not matching as expected, so I uncommented the debugging line in subtype_dynamic_cast from xtl.hpp.

My stringify function is being used to serialize ASTs, and accepts a reference to a Node (the root of the type DAG), since it needs to be able to handle any node and has a void return type. In this case, the debug print shows:

subtype_dynamic_cast<PKN4GPSM7PolygonE>(PKN4GPSM4NodeE) = 0x102813d00

When fed a Polygon. However, matching on the same Polygon (in a context where the reference is to a Expr, an intermediate type between Polygon and Node), I get:

subtype_dynamic_cast<PKN4GPSM7PolygonE>(PN4GPSM4ExprINS_7SurfaceENS_6AnyValEEE) = 0x0

Nonetheless, my own debug print of the typeid() shows N4GPSM7PolygonE.

Background:

I wanted to be able to build type predicates without the use of preprocessor macros

template<typename T> struct makeTypePredicate {
    bool operator()(const AstNode *n){
        Match(n){
            CaseInT(mch::C<T>()){ return true; }
        } EndMatch;

        return false;
    }
};

I was wondering if there's any plan to making Mach7 stand-alone with the introduction of std::variant and std::visit in C++, in comparison to boost::variant currently used on master. I briefly searched open issues but maybe I missed the relevant conversation.

Is there any additional dependencies on boost except variant?

Discussion in #67 and https://github.com/solodon4/Mach7/blob/master/code/test/unit/example04-smart-ptr.cpp notes that binding a reference from a smart pointer is unwieldy due to poor language support for proxies.

It seems that being able to unpack directly into the target variables via structured bindings would make for a much cleaner solution.

Are there any major hurdles in the existing implementation to doing this?

I'm working on a statically type-checked DSL. An expression node of type T has type Expr<T>, and definition of T itself (representing a literal) is something like class T : Expr<T>. There are a handful of Expr-subclasses that still have unbound type parameters (i.e. Let<U,T> binds variables of type U and returns a value of type T).

I would like to, at a minimum, be able to pattern match over bounded sets of possible U and T without resorting to (manual) copy-paste.

The annoying, but reasonably scalable for a small set of types, solution would be a copy-paste macro.

The nice and extensible solution would be some ability to pattern match based on a variance specification for template arguments: if A is a subtype of B, then being able to match an instance of Expr<A> in a pattern that specifies Expr<B> would be ideal (in Scala notation, the pattern would be for Expr<+B>).

I suspect I'm not the only person who would like to be able to do something like this, and I'm wondering what the obstacles are to implementation.

I am working on a concurrent implementation of your C++ Pattern Matching Library. Currently I am working with the vtblmap3st file using reader/writer locks to see if this out performs a single lock. I have a question whether or not locking/unlocking the shared and non-shared locks where the reference to the pointer ce is returned is safe, or this could corrupt the data in the cache.

Env: clang++ with clang++ --version:

clang version 3.8.0 (tags/RELEASE_380/final)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /usr/sbin

Description

This code produces the error

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff6121d54 in __memmove_ssse3_back () from /usr/lib/libc.so.6

at this line. As you can see params is an instance of the var template which I'm trying to fill with a copy of the member argv_ of the ExpFunc object. The type of argv is vector<Expression*> and argv_ is stored as non-pointer, non-reference in ExpFunc. params was instanciated as follows:

var<vector<Expresson *>> params;

You can find the whole test here. I deleted most of the other unit tests and the respective include files in order to make sure that the error arises from a use of Mach7.

Is it possible to mix instances of var and nested patterns in the binding part of a constructor pattern? For example, is the following code allowed:

Case(C<ExpLogical>(
         C<ExpRelation>(
             C<ExpCharacter>(charVal),
             C<ExpName>(name),
             relOp),
         C<ExpAttribute>(attrName),
         logOp)){

where attrName, name, charVal, logOp and relOp are instances of the var template and Exp* have the layout:

namespace mch {
    template <> struct bindings<ExpUNot> {
        Members(ExpUNot::operand1_);
    };

    template <> struct bindings<ExpCharacter> {
        Members(ExpCharacter::value_);
    };

    template <> struct bindings<ExpAttribute> {
        Members(ExpAttribute::name_);
    };

    template <> struct bindings<ExpLogical> {
        Members(ExpLogical::operand1_,
                ExpLogical::operand2_,
                ExpLogical::fun_);
    };

    template <> struct bindings<ExpFunc> {
        Members(ExpFunc::name_,
                ExpFunc::argv_);
    };

    template <> struct bindings<ExpName> {
        //TODO: add prefix
        Members(//ExpName::prefix_, // unique_ptr<ExpName>
                ExpName::name_,
                ExpName::indices_);
    };

    template <> struct bindings<ExpRelation> {
        Members(ExpRelation::operand1_,
                ExpRelation::operand2_,
                ExpRelation::fun_);
    };
};

Here some Context. I need to search an Expression AST for a very specific pattern. Without the ExpRelation::fun_ and ExpLogical::fun_ bindings it worked quite well, but when I first began to experiment with the first code snippet instead of the simpler

Case(C<ExpLogical>(
         C<ExpRelation>(
             C<ExpCharacter>(charVal),
             C<ExpName>(name)),
         C<ExpAttribute>(attrName))){

no pattern seemed to match anymore.