aggregates syntax

[jedi1992]

Aggregates like List, count, Max have a syntax like value? Max= val when occurring in the left hand side in the predicate definition.
In some functions like what you had mentioned we call it as Max(val) inside the function.

MinOrMax({val:, cmd:}) = (if cmd == "Min" then Min(val) else Max(val));

Are these aggregate syntax(es) consistent with say Datalog or is this very specific to Logica. ( like an syntax extension). And also having something like value? Max = val how would you explain this in terms of Logica syntax itself. It uses = but does not feel like a function. Also when using Min inside the MinOrMax it does not feel like it is getting a column of values.

So the question is are these aggreagate syntax a convenient syntax extensions or does the syntax arise from some more fundamental principle. If from a fundamental principle then what is it ?

[EvgSkv]

Thanks for bringing this up! We should explain this topic better in the tutorial.
Once we introduce functional notation (which isn't there in classic Datalog) this syntax for aggregate functions comes out naturally.
Aggregate functions are treated by Logica mostly like regular functions (with the only exception of multi-body aggregation, where the aggregation function is moved on top of the union, but this is a topic for another discussion).

Let's consider an example of regular function use:

F(x:) = 2 * x;
Q(a: x,b: F(x:)) :- x in Range(5);

When compiling this Logica interprets value of F as logica_value column, so definition is equivalent:

F(x:, logica_value: 2 * x);

Then when F is used the call to F is replaced with logica_value, so Q is compiled as:

Q(a: x, b: f_value) :- x in Range(5), F(x:, logica_value: f_value);

Now let's look at a situation when F is an aggregate function.

F(x) = 2 * Sum(x);
Q(s? F= x) distinct :- x in Range(5);

First of all let's make call to F less magical. It may be easier to understand what's going on if we write the same program in this form:

F(x) = 2 * Sum(x);
Q(s? Aggr= F(x)) distinct :- x in Range(5);

You can run this to check that result is the same. Aggr function just lets you specify that the column needs to be aggregated and use aggregate functions in the value. This form is more similar to SQL, where aggregate functions look exactly like regular functions and you need to know which is which.

In this form function F is treated just as before:

Q(s? Aggr= f_value) distinct :- x in Range(5), F(x, logica_value: f_value);

Next step definition of F is substituted:

Q(s? Aggr= f_value) distinct :- x in Range(5), f_value == 2 * Sum(x);

And finally we end up with:

Q(s? Aggr= 2 * Sum(x)) distinct :- x in Range(5);

Thus this form of defining aggregate functions is consistent with Datalog semantics once you extended Datalog with aggregation and functions.

Hope this helps. I will spend more time thinking how to explain this concept in a way that's easier to understand.