The simple solution: output=$(complex_command) status=$? if (( status == 0 )); then : stuff with “$output” fi : more code if (( status == 0 )); then : stuff with “$output” fi Or more eleganter-ish do_complex_command () { # side effects: global variables # store the output in $g_output and the status in $g_status g_output=$( … Read more
Bozho’s 2nd revised answer was close but not quite there. It did lead me to the answer though. Taking the code example I started with we end up with: CallableStatement proc = connection.prepareCall(“{ ? = call dbo.mySproc() }”); proc.registerOutParameter(1, Types.INTEGER); proc.execute(); int returnValue = proc.getInt(1); The key pieces here are the “? =” in front … Read more
The short answer, is because the C++ standard requires main() to return int. As you probably know, the return value from the main() function is used by the runtime library as the exit code for the process. Both Unix and Win32 support the concept of a (small) integer returned from a process after it has … Read more
int f(char) { return 0; } int (*return_f())(char) { return f; } No, seriously, use a typedef 🙂
As T-Me correctly inferred before you posted the CreateDatedFolder source, the problem is that the function inadvertently outputs 2 objects, and Join-Path accepts an array of parent paths to each join with the child path. Specifically, it is the New-Item call that accidentally creates an additional output object, just before your return $datedDir call. New-Item … Read more
Here is a possible example. The structure is the same as in the answer in my comment. The second Stage is opened through a “controller” that is stores the data that should be returned even when the Stage is closed and exposes a getter to be used to retrieve the value from the outer world. … Read more
Typescript will not infer different return types based on type guards in the function. You can however define multiple function signatures for let the compiler know the links between input parameter types and result type: function ff(x: boolean): boolean; function ff(x: string): string; // Implementation signature, not publicly visible function ff(x: boolean | string): boolean … Read more
UPDATE: The desired feature is now supported in C# 7. The CLR type system does support ref-returning methods, and I have written an experimental prototype of the C# compiler which supports the feature you want. (The prototype also implements ref-typed local variables, but ref-typed fields are illegal in the CLR type system.) You have hit … Read more
One way I’ve seen is to pass a mutable object, such as a list or a dictionary, to the thread’s constructor, along with a an index or other identifier of some sort. The thread can then store its results in its dedicated slot in that object. For example: def foo(bar, result, index): print ‘hello {0}’.format(bar) … Read more
You need to use Promises for this. They are available in ES6 but can be polyfilled quite easily: function x() { return new Promise((resolve, reject) => { setTimeout(() => { resolve(‘done!’); }); }); } x().then((done) => { console.log(done); // –> ‘done!’ }); With async/await in ES2017 it becomes nicer if inside an async function: async … Read more