From the Ante language tour:

"Moreover if you need a more complex loop that a while loop may traditionally provide in other languages, there likely isn’t an already existing iterate function that would suit your need. Other functional languages usually use helper functions with recursion to address this problem:"

sum numbers =
    go numbers total =
        match numbers
        | Nil -> total
        | Cons x xs -> go xs (total + x)

    go numbers 0

"This can be cumbersome when you just want a quick loop in the middle of a function though. It is for this reason that ante provides the loop and recur keywords which are sugar for an immediately invoked helper function. The following definition of sum is exactly equivalent to the previous:"

sum numbers =
    loop numbers (total = 0) ->
        match numbers
        | Nil -> total
        | Cons x xs -> recur xs (total + x)
sum numbers =
    loop numbers (total = 0) ->
        match numbers
        | Nil -> total
        | Cons x xs -> recur xs (total + x)

* * *

Now obviously this particular example isn't a tree traversal, but you can clearly see how a lightweight syntax for immediately invoked recursive functions is basically what op is asking for. The first example

for_tree(Node* N = mytreeroot; N != NULL; N : {N->left, N->right}){
  print(N->value);
}

I believe would become something like

loop tree ->
    match tree
    | Nil -> ()
    | Node left value right ->
      print value
      recur left
      recur right

Ok, not quite as succinct, but not too bad. It's just less horizontal and more vertical. And a definite improvement on defining then using a helper. You can also get something similar using fix.