Unexpected structural cycle

[YWalen]

I have two examples. Example 1:

#Inherit:  {
    #parent: _
    for k, v in #parent {
        if (v & {...}) != _|_ {
            (k): #Inherit & { #parent: v }
        }
        if (v & {...}) == _|_ {
            (k): *v | _
        }
    }
    ...
}

#layer1: {
    depth_1: {
        depth_2: {}
    }
}

layer_2: #Inherit & {
    #parent: #layer1
}

Example 2:

#Inherit:  {
    #parent: _
    for k, v in #parent {
        if (v & {...}) != _|_ {
            (k): #Inherit & { #parent: v }
        }
        if (v & {...}) == _|_ {
            (k): *v | _
        }
    }
    ...
}

#layer1: {
    depth_1: {
        depth_2: {
            depth_3: {}
        }
    }
}

layer_2: #Inherit & {
    #parent: #layer1
}

Example 1 works as expected but example 2 gives error:
layer_2.depth_1.depth_2.depth_3: structural cycle

Is this a bug or a feature? Is too much recursion not allowed in a for loop? I know this is not the intended way to use cue but I am trying something. Please let me know or educate me!

[perelo]

I'll let the CUE team will correct me if I'm mistaken, but I think the evaluator indeed does limit recursion when disjunctions are involved, in order to ensure termination. There is no specific error for this, so the actual reports vary a lot.

Had been playing with this kind of pattern a while ago, looking to implement a struct merge that allows overriding values (aka. destructive), which seems like what you're after. The code looks a lot like yours, but I've moved the struct checking above the loop, and used the *{ ... } | v to stop the recursion when the default fails. Surprisingly, the termination checker is happy.
https://cuelang.org/play/?id=wDzyyWWWU7s#w=function&i=cue&f=eval&o=cue

#Merge is used to merge fst and snd with different methods. Your #Inherit could then be written using the self keyword to pass the "current" struct. Requires the aliasv2 experiment for the keyword, otherwise use #Inherit: self={ ... }.

#Inherit: {
    #parent: _
    let this = self
    (#Merge & { fst: #parent, snd: this }).recursive
    ...
}

The try proposal would also help here, but as you mentioned, this kind of programming in CUE is discouraged, it pushes the evaluator to its boundaries.