I'm currently working on an implementation of the following idea, and I was wondering if there is any literature on this subject.

Working with Java, but the principle applies on any language with a decent type-system, I like to implement: matching Objects from a List using a RegularExpression-esque search:

So let's say I have a List containing

List<Object> x = new ArrayList<Object>();
x.add(new Object());
x.add("Hello World");
x.add("Second String");
x.add(5); // Integer (auto-boxing)
x.add(6); // Integer

Then I create a "Regular Expression" (not working with a stream of characters, but working with a stream of Objects), and instead of character-classes, I use type-system properties:

[String][Integer]

And this would match one sublist: {Match["Second String", 5]}. The expression:

[String:length()<15]

Will match two sublist (each of length 1) containing a String which instance is passing the expression instance.length() < 5: {Match["Hello World"],Match["Second String"]}.

[Object][Object]

Matches any pair in the List: {Match[Object,"Hello World"],Match["Second String", 5]}, in a streamed manner (no overlapping matches).

Ofcourse, my implementation will have grouping, lookahead/lookbehinds and is hierarchical (i.e. matching n elements from Lists in Lists), etc. The above merely illustrates the concept.

Is there a name for this principle, and is there literature available on it?