Union of elements from separate sets

[CICS-Oleg]

Suppose we have a knowledge base:

(a title1 tutorial1)
(a creator Alice)

(b title2 tutorial2)
(b creator Bob)

(c title1 tutorial3)
(c title2 tutorial3Updated)

1. I want a query to get something like this:

[tutorial1, tutorial2, tutorial3, tutorial3Updated]

2. and query, which will give something like that:

[(tutorial1, tutorial3), (tutorial2, tutorial3Updated)]

I can do something like that as a wrong attempt to solve the first task:

!(unify &self (, ($x title1 $title) ($y title2 $title2)) (superpose ($title $title2)) Fail)

But it will obviously generate an explicit set of nondeterministic results in the form of

[tutorial2, tutorial1, tutorial3Updated, tutorial1, tutorial2, tutorial3, tutorial3Updated, tutorial3]

Same as if I try to solve the second task by this

!(match &self (, ($x title1 $title) ($y title2 $title2)) ($title $title2))

The result is all possible pairs of titles 1 and 2:

[(tutorial1 tutorial3Updated), (tutorial1 tutorial2), (tutorial3 tutorial3Updated), (tutorial3 tutorial2)]

But what I want is to get set of titles which is

1. union of title1 and title2 types of titles
2. 2 tuples with title1 names and title2 names respectively.

An order of names in the union and tuples in the resulting output "list" does not matter.

[CICS-Oleg]

Suppose for the same base

(a title1 tutorial1)
(a creator Alice)

(b title2 tutorial2)
(b creator Bob)

(c title1 tutorial3)
(c title2 tutorial3Updated)

we have this type of command

!(match &self ($x $y $title)
               (case $y
                    ((title1 $title)
                    (title2 $title)
                    ($_ Empty))))

Why would this not work?

The result is

[tutorial3Updated, tutorial3, tutorial1, tutorial2, title1, title1, title1, title1, title1, title1, $first#240, title1, title1, $arg2#282, $arg1#281, title1, title1, title1, title1, title1, title1, title1, title1, title1, title1]

Looks like all variables tackled unordered in the tuple.

[Necr0x0Der]

As for the last one: &self is not a clean space. it imports a lot of stuff to make language do something useful. This

!(match &self ($x $y $title) ...

is the worst query possible (except for (match &self $x...)), because there are many equalities (= (func ...) body), and they are all retrieved by this pattern ($x $y $title). It wouldn't be that terrible, but in the following

!(match &self ($x $y $title)
               (case $y

$y is executed before being passed to case, and $y will be a function call with variables instead of arguments. So it will be executed and return something, which can also be a variable, which can be matched against title1 or title2 producing multiple results. E.g., for (= (id $x) $x), which is one among many imported stdlib functions, !(match &self ($x $y $title) ... will bind $y to (id $x) and executing (id $x) will give $x, which will be matched against anything.

One can avoid this via quoting, e.g.

(a title1 tutorial1)
(a creator Alice)
(b title2 tutorial2)
(b creator Bob)
(c title1 tutorial3)
(c title2 tutorial3Updated)
!(match &self ($x $y $title)
              (case (quote $y)
                  (((quote title1) $title)
                   ((quote title2) $title)
                   ($_ Empty))))

will produce [tutorial1, tutorial2, tutorial3, tutorial3Updated], which looks like what is intended.
This is still not a good way to do this, because a lot of unrelated equality triples will be retrieved before case.
That's why I always recommend to wrap your data entries into specific constructors if you want to use &self or mix up heterogeneous data in one space. Say,

(Entry (a title1 tutorial1))
(Entry (a creator Alice))
(Entry (b title2 tutorial2))
(Entry (b creator Bob))
(Entry (c title1 tutorial3))
(Entry (c title2 tutorial3Updated))
!(match &self (Entry ($x $y $title))
              (case $y
                  ((title1 $title)
                   (title2 $title)
                   ($_ Empty))))

will work perfectly well.
This solution has its overhead, of course.

Another solution is to use clean separate space to store simple triples with their own semantics, e.g.

!(bind! &space (new-space))
!(add-atoms &space (
    (a title1 tutorial1)
    (a creator Alice)
    (b title2 tutorial2)
    (b creator Bob)
    (c title1 tutorial3)
    (c title2 tutorial3Updated)
))

!(match &space ($x $y $title)
               (case $y
                  ((title1 $title)
                   (title2 $title)
                   ($_ Empty))))

will also work well.

[Necr0x0Der]

As for the first part, either

!(unify &self (, ($x title1 $title) ($y title2 $title2))
     (superpose ($title $title2)) Fail)

or

!(match &self (, ($x title1 $title) ($y title2 $title2)) ($title $title2))

will enumerate all pairs ($x title1 $title) x ($y title2 $title2), and since these patterns don't have common variables, these would be really all combinations of matches for the first and for the second pattern.
Apparently, you meant something like

!(superpose (
  (match &self ($x title1 $title) $title)
  (match &self ($x title2 $title) $title)))

You can unite the results of two queries in another way, but these should be just two different queries.

There is a way to make it one query by using non-deterministic pattern:

!(let $titles (superpose (title1 title2))
    (match &self ($x $titles $title) $title))

It's elegant, but somewhat esoteric.

[Necr0x0Der]

It's definitely a good material for the whole tutorial :)