So we can have nested functions, right? And if we say `return`

, it’s relative to scope: if I say `return`

within a nested function it means the end of that function, but not of the larger one. But what if I’m inside a second-layer function and generate The Answer that ends the outer function?

Example: some of my thoughts so far on the Arguments Optional algorithm:

```
function addTogether() {
var args = [...arguments];
args.every(function(element){
// if typeof element is not "number"--then that's the end of the whole ball game, right there!
// return undefined--but not just "return" within the context of *this* function; time to "return" undefined for the whole addTogether function!
})
if (args.length === 2) {
return args[0] + args[1]; // That's the easy part. "If there are two arguments, add 'em."
} else if (args.length === 1) {
return function addEm(x) {
return addTogether(args[0], x); // I know, this still needs work
};
}
}
```

In the `args.every`

function, if I say `return`

, I’m within the scope of that function, not the whole big overall function. I suppose I could just dodge the issue by using a for loop instead of .every, but I feel like I’ll be in this situation again and want to know. Is there a way to “return” the parent function from within a child function?