Accumulate (set of) entities within a function call

[JeffreyBenjaminBrown]

Problem to Solve

Accumulate entities within a function call

"Accumulate entities within a function call" is really the whole idea, but here's a motivating illustration. Please inform me if there is already a way to do this!

Consider a relation 'contains' from 'container' to 'content'.
Suppose we need the function 'first-containerward-nonlinearity'
which takes a node and returns a node,
where a 'terminus' satisfies any of these conditions:

• being a root (does not play 'content')
• being a fork (plays 'content' more than once)
• being one of the nodes our containerward traversal already saw

So for instance, given this data:

#+begin_example
a contains b
b contains c
c contains a <-- a again!
a contains d
d contains e
#+end_example

calling first-containerward-nonlinearity' on 'e' yields 'a',
finding it by traversing containerward
until hitting 'a' the second time.

To define this function, I seem to need to be able to accumulate during its execution. Do I not? If I do, is that expressible?

Current Workaround

I can make individual containerward calls from Rust and accumulate there. It works but it's slow.

Proposed Solution

I think this requires syntax for accumulating entities within a function call. If I'm wrong and there's another way I'd love to know.

An insufficient solution

Claude suggested preempting the response "use a depth counter". That would not work because the depth to the cycle entry point is unpredictable.

[krishnangovindraj]

Accumulating would need lists. Implementing them is likely a fair few months away.

For your example:
Can you take a computation overhead? How big are these paths typically?
Can you consider expressing the solution declaratively as you did in your post?

Here's an example but we can try to optimise it if needed:

fun containerwards_from($node: node) -> { node }:
match 
  { $_ isa container, links (contained: $node, $container: $hop); } or 
  {  $_ isa container, links (contained: $node, $container: $mid); let $hop in containerwards_from($mid); }
return { $hop };

fun is_non_linearity($node: node) -> bool:
  { not { $_ isa container, links (contains: $node); };  } or 
  { 
    $_ isa container, links (contains: $node, container: $first);  
    $_ isa container, links (contains: $node, container: $second);  
    not { $first is $second; };
  } or  
  { 
     let $other in containerwards_from($node);
     $other is $node;
}; 
return check;

To find the first is a bit trickier when it's due to a cycle. Can you start in a cycle? (in which case the non-linearity is the start-node itself)

[JeffreyBenjaminBrown]

Accumulating would need lists.

Sets would be more efficient in this case. I've edited the post title accordingly

Implementing them is likely a fair few months away.

Oh cool! I can wait. Nobody uses this app but me yet. Thank you!