One way to break out of a recursive function in Python is to throw an exception and catch that at the top level. Some people will say that this is not the right way to think about recursion, but it gets the job done. Furthermore, if the task is to identify "problem" elements in an array/array of arrays/ndarray etc., a break technique is convenient, because it stops the algorithm from continuing after the global solution has been identified.

def solve_problem(lst):
    def solve_rec(l):
        '''has impl. that may throw an exception '''
    try:
        solve_rec(lst)
        return True
    except:
        return False

Just return at that point, if you want to propagate the result back up.

For instance, if you want to return the first non-float found:

def flatten(arr):
    for elem in arr:
        if isinstance(elem, collections.Iterable) and not isinstance(elem, (str, bytes)):
            res = flatten(elem)
            if res is not None: # add this if you want to return the first one
                break
        else:
            if not isinstance(elem, float):
                return elem

    return res

Try

function findCategory(categoryName) {
    var trail = [];
    var found = false;

    function recurse(categoryAry) {

        for (var i = 0; i < categoryAry.length; i++) {
            trail.push(categoryAry[i].category);

            // Found the category!
            if ((categoryAry[i].category === categoryName)) {
                found = true;
                break;

                // Did not match...
            } else {
                // Are there children / sub-categories? YES
                if (categoryAry[i].children.length > 0) {
                    recurse(categoryAry[i].children);
                    if(found){
                        break;
                    }
                }
            }
            trail.pop();
        }
    }

    recurse(catalog);

    return trail
}

Demo: Fiddle

The function combo I was looking for is CATCH/THROW. Once again, using the given function:

walk: func [series [block!] criteria [block!]][
    use [value] compose/deep [
        while [not tail? series][
            value: pick series 1

            either block? value [
                walk value criteria
            ][
                (to paren! criteria)
            ]

            series: next series
        ]
    ]
]

I can simply wrap it as follows:

catch [walk [a [b c [d e] f] g] [if value = 'e [throw value]]]
; returns 'e

Some Notes

• I want the function to return NONE if there are no matches

I'll just have WALK return NONE (am using ALSO just so as not to leave an awkward trailing none):

 walk: func [series [block!] criteria [block!]][
      also none use [value] compose/deep [
          while [not tail? series][
              value: pick series 1

              either block? value [
                  walk value criteria
              ][
                  (to paren! criteria)
              ]

              series: next series
          ]
      ]
  ]

• red does not have a USE function

This introduces a complication as I only want to bind the block to the word VALUE. If I were to rewrite the function as follows:

walk: func [series [block!] criteria [block!] /local value][
    do bind compose/deep [
        while [not tail? series][
            value: pick series 1

            either block? value [
                walk value criteria
            ][
                (to paren! criteria)
            ]

            series: next series
        ]
    ] 'value
]

Then it also binds that same block to the words SERIES and CRITERIA which would override the binding of any such words from the calling context, e.g.:

walk [some values][series: none probe value] ; results in error

You could use exceptions for that - either throw some suitable exception or craft your own and use it. Although using exceptions for flow control is generally not recommended this is the only reliable way here.

Three changes are needed. First, you need to return something once you solved it:

    printf ("%s : %6d\n", s3 , n3);
    return 1;

Next, you need to check the return value when you recurse, and stop if you found a solution:

    if (solve (v, n, i+1,s1,s2,s3,letters))
        return 1;

Last, if you don't find a solution, you need to return 0:

    }
    return 0;
}