    void run() {
        ...
        if (done) return cancel();
        ...
    }

where `cancel()` return `void`. This won&#39;t compile... and I can *almost* understand why. But if I want to return a void from a void, why not? Instead, I end up writing something like this:

    if (done) {
        cancel();
        return;
    }

I&#39;m not looking for code style suggestions, I want to know why Java expressly prohibits this type of void return. Any info is appreciated, thanks.

Why can&#39;t I explicitly return void from a method?

I am not sure what the difference is between specifying Unit as the return type of my scala method or leaving out the return type altogether. What is the difference?

Can anyone please advise?

Should I use Unit or leave out the return type for my scala method?

I was testing return types with PHP 7.
 
I&#39;ve created a simple script to test return types of PHP 7:

    &lt;?php
    
    Class Obj {
        
        public function __construct(){
            
        }
        
        public function test(): string { //a string needs to be returned
            return &quot;ok&quot;;
        }
        
    }
    
    function foo(): Obj { //instance of Obj needs to be returned
        return new Obj();
    }
    
    $o = foo();
    echo $o-&gt;test(); // output: ok

Now in other programming languages when you specify a return type `void` it means you cannot return anything or you will get an error. So I wrote this script:

    &lt;?php

        function foo(): void {
    
        }
    
        foo(); 

Now in above script the expected output is nothing. 
Instead it gives me a Fatal error:

&gt;Fatal error: Return value of foo() must be an instance of void, none returned on line 2

My question is (I couldn&#39;t find it), in PHP 7 will there be a similar `void` type?

Void as return type

How to do this in pandas:

I have a function `extract_text_features` on a single text column, returning multiple output columns. Specifically, the function returns 6 values.

The function works, however there doesn&#39;t seem to be any proper return type (pandas DataFrame/ numpy array/ Python list) such that the output can get correctly assigned `df.ix[: ,10:16] = df.textcol.map(extract_text_features)`

So I think I need to drop back to iterating with `df.iterrows()`, as per [this](https://stackoverflow.com/questions/7837722/what-is-the-most-efficient-way-to-loop-through-dataframes-with-pandas)?

UPDATE: 
Iterating with `df.iterrows()` is at least 20x slower, so I surrendered and split out the function into six distinct `.map(lambda ...)` calls.

UPDATE 2: this question was asked back around [v0.11.0](https://github.com/pandas-dev/pandas/releases?after=v0.13.0_ahl1), before the useability `df.apply` was improved or [`df.assign()`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.assign.html) was [added in v0.16](https://pandas.pydata.org/pandas-docs/stable/whatsnew/v0.16.0.html?highlight=assign). Hence much of the question and answers are not too relevant.

Apply pandas function to column to create multiple new columns?

Why isn&#39;t there a (standard, Java certified) solution, as part of the Java language itself, to return multiple values from a Java method, rather than developers having to use their own means, such as Maps, Lists, Pairs, etc.? Why does Java not support n-tuple objects?

Especially thinking for trivial private methods that may modify two objects together (in tandem), and in which case a typed-object as a return sounds overkill.

Return multiple values from a Java method: why no n-tuple objects?

Given a very simple, but lengthy function, such as:

    int foo(int a, int b, int c, int d) {
    	return 1;
    }
    
    // using ReturnTypeOfFoo = ???

What is the most simple and concise way to determine the function&#39;s return type (`ReturnTypeOfFoo`, in this example: `int`) at compile time *without repeating the function&#39;s parameter types* (by name only, since it is known that the function does not have any additional overloads)?

Simplest way to determine return type of function

Given a typeclass where instance selection should be performed based on the return type:

    case class Monoid[A](m0: A) // We only care about the zero here
    implicit def s[T] : Monoid[Set[T]] = Monoid(Set.empty[T])
    implicit def l[T] : Monoid[List[T]] = Monoid(List.empty[T])
    def mzero[A](implicit m: Monoid[A]) : A = m.m0

why does Scala (2.11.6) fail to resolve the proper instance:

    scala&gt; mzero : List[Int]
    &lt;console&gt;:24: error: ambiguous implicit values:
     both method s of type [T]=&gt; Monoid[Set[T]]
     and method l of type [T]=&gt; Monoid[List[T]]
     match expected type Monoid[A]
                  mzero : List[Int]
                  ^

when it has no problems finding an implicit based on the return type when using the **implicitly** function (we redefine it here as **i** to illustrate how similar it is to **mzero**)

    def i[A](implicit a : A) : A = a
    scala&gt; i : Monoid[List[Int]]
    res18: Monoid[List[Int]] = Monoid(List())

The `Monoid[A]`, instead of `Monoid[List[Int]]` in the error message is puzzling.

I would assume many scalaz contributors to be familiar with this problem as it seems to limit the convenience of typeclasses in scala.

EDIT: I&#39;m looking into getting this working without forgoing type inference. Otherwise I&#39;d like understand why that&#39;s not possible. If this limitation is documented as a Scala issue, I could not find it.

Unexpected implicit resolution based on inference from return type

Is there a way to make this method generic so I can return a string, bool, int, or double?  Right now, it&#39;s returning a string, but if it&#39;s able find &quot;true&quot; or &quot;false&quot; as the configuration value, I&#39;d like to return a bool for example.


        public static string ConfigSetting(string settingName)
        {  
             return ConfigurationManager.AppSettings[settingName];
        }


How do I make the return type of a method generic?

PHP 7 introduces [return type declarations][1]. Which means I can now indicate the return value is a certain class, interface, array, callable or one of the newly hintable scalar types, as is possible for function parameters.

    function returnHello(): string {
    	return &#39;hello&#39;;
    }

Often it happens that a value is not always present, and that you might return either something of some type, or null. While you can make parameters nullable by setting their default to null (`DateTime $time = null`), there does not appear to be a way to do this for return types. Is that indeed the case, or am I somehow not finding how to do it? These do not work:

    function returnHello(): string? {
    	return &#39;hello&#39;;
    }

    function returnHello(): string|null {
    	return &#39;hello&#39;;
    }
  [1]: http://php.net/manual/en/functions.returning-values.php#functions.returning-values.type-declaration

Nullable return types in PHP7

What is the correct (most efficient) way to define the `main()` function in C and C++ — `int main()` or `void main()` — and why? And how about the arguments?
If `int main()` then `return 1` or `return 0`?

&lt;hr&gt;

_There are numerous duplicates of this question, including:_

* [What are the valid signatures for C&#39;s `main()` function?](https://stackoverflow.com/questions/2108192/what-are-the-valid-signatures-for-cs-main-function/)
* [The return type of `main()` function](https://stackoverflow.com/questions/17715008/the-return-type-of-main-function/)
* [Difference between `void main()` and `int main()`?](https://stackoverflow.com/questions/636829/difference-between-void-main-and-int-main)
* [`main()`&#39;s signature in C++](https://stackoverflow.com/questions/1621574/mains-signature-in-c)
* [What is the proper declaration of `main()`?](https://stackoverflow.com/questions/4207134/what-is-the-proper-declaration-of-main) — For C++, with a very good answer indeed.
* [Styles of `main()` functions in C](https://stackoverflow.com/questions/8692120/styles-of-main-functions-in-c)
* [Return type of `main()` method in C](https://stackoverflow.com/questions/10915713/return-type-of-main-method-in-c)
* [`int main()` vs `void main()` in C](https://stackoverflow.com/questions/9356510/int-main-vs-void-main-in-c)

Related:

* [C++ — `int main(int argc, char **argv)`](https://stackoverflow.com/questions/5191965/c-int-mainint-argc-char-argv)
* [C++ — `int main(int argc, char *argv[])`](https://stackoverflow.com/questions/5217395/c-int-mainint-argc-char-argv)
* [Is `char *envp[]` as a third argument to `main()` portable?](https://stackoverflow.com/questions/10321435/is-char-envp-as-a-third-argument-to-main-portable)
* [Must the `int main()` function return a value in all compilers?](https://stackoverflow.com/questions/18402853/must-the-int-main-function-return-a-value-in-all-compilers)
* [Why is the type of the `main()` function in C and C++ left to the user to define?](https://stackoverflow.com/questions/5296163/why-is-the-type-of-the-main-function-in-c-and-c-left-to-the-user-to-define)
* [Why does `int main(){}` compile?](https://stackoverflow.com/questions/22239/why-does-int-main-compile)
* [Legal definitions of `main()` in C++14?](https://stackoverflow.com/questions/26470912/legal-definitions-of-main-in-c14)


What should main() return in C and C++?

Sorry if this is pretty noobish, but I&#39;m pretty new to C++. I&#39;m trying to open a file and read it using `ifstream`:

    vector&lt;string&gt; load_f(string file) {
      vector&lt;string&gt; text;
    
      ifstream ifs(file);
      string buffer, str_line;
    
      int brackets = 0;
      str_line = &quot;&quot;;
    
      while ( getline(ifs, buffer) ) {
        buffer = Trim( buffer );
        size_t s = buffer.find_first_of(&quot;()&quot;);
    
        if (s == string::npos) str_line += &quot;&quot; + buffer;
        else {
          while ( s != string::npos ) {
            str_line += &quot;&quot; + buffer.substr(0, s + 1);
            brackets += (buffer[s] == &#39;(&#39; ? 1 : -1);
    
            if ( brackets == 0 ) {
              text.push_back( str_line );
              str_line = &quot;&quot;;
            }
    
            buffer = buffer.substr(s + 1);
            s = buffer.find_first_of(&quot;()&quot;);
          }
        }
      }
    
      return text;
    }

However, I&#39;m getting the following error I&#39;m not quite sure how to fix:

    variable &#39;std::ifstream ifs&#39; has initializer but incomplete type

Answers very appreciated. Note that I never forgot to `#include &lt;fstream&gt;`, since many have gotten the error due to just forgetting to include the header.

**EDIT:**

Turns out that I actually did forget to include `fstream`, but I had forgotten due to moving the function to another file.

C++: variable &#39;std::ifstream ifs&#39; has initializer but incomplete type

I have read that .NET supports return of references, but C# doesn&#39;t. Is there a special reason? Why I can&#39;t do something like:

    static ref int Max(ref int x, ref int y) 
    { 
      if (x &gt; y) 
        return ref x; 
      else 
        return ref y; 
    } 

Why doesn&#39;t C# support the return of references?

In looking at various C# Async CTP samples I see some async functions that return `void`, and others that return the non-generic `Task`.  I can see why returning a `Task&lt;MyType&gt;` is useful to return data to the caller when the async operation completes, but the functions that I&#39;ve seen that have a return type of `Task` never return any data.  Why not return `void`?

What&#39;s the difference between returning void and returning a Task?

I have this function in PostgreSQL, but I don&#39;t know how to return the result of the query:

    CREATE OR REPLACE FUNCTION wordFrequency(maxTokens INTEGER)
      RETURNS SETOF RECORD AS
    $$
    BEGIN
        SELECT text, count(*), 100 / maxTokens * count(*)
        FROM (
            SELECT text
	    FROM token
	    WHERE chartype = &#39;ALPHABETIC&#39;
	    LIMIT maxTokens
        ) as tokens
        GROUP BY text
        ORDER BY count DESC
    END
    $$
    LANGUAGE plpgsql;

But I don&#39;t know how to return the result of the query inside the PostgreSQL function.

I found that the return type should be `SETOF RECORD`, right? But the return command is not right.

What is the right way to do this?

How to return result of a SELECT inside a function in PostgreSQL?

I&#39;ve created a method, and the return is `Result&lt;R&gt;` in a class of `MyClass&lt;R&gt;`, but the error message is: &#39;kotlin.Result&#39; cannot be used as a return type

I&#39;ve also looked into the Result source code for some hints; why is this so?

[Test code][1] (using v. 1.3-RC).

    class MyClass&lt;R&gt;(val r: R) {
        fun f(): Result&lt;R&gt; { // error here
            return Result.success(r)
        }
    }
    
    fun main(args: Array&lt;String&gt;) {
        val s = Result.success(1)
        val m = MyClass(s)   
    }


  [1]: https://try.kotlinlang.org/#/UserProjects/ueeogpr0cqnovot7o4ooa42dv5/l9qidpqj9pf1i7rablka4u5qjt

Why can&#39;t &#39;kotlin.Result&#39; be used as a return type?

I am trying to change some for-each loops to lambda `forEach()`-methods to discover the possibilities of lambda expressions. The following seems to be possible:

    ArrayList&lt;Player&gt; playersOfTeam = new ArrayList&lt;Player&gt;();      
    for (Player player : players) {
        if (player.getTeam().equals(teamName)) {
            playersOfTeam.add(player);
        }
    }

With lambda `forEach()`

    players.forEach(player-&gt;{if (player.getTeam().equals(teamName)) {playersOfTeam.add(player);}});

But the next one doesn&#39;t work:

    for (Player player : players) {
        if (player.getName().contains(name)) {
            return player;
        }
    }

with lambda

    players.forEach(player-&gt;{if (player.getName().contains(name)) {return player;}});

Is there something wrong in the syntax of the last line or is it impossible to return from `forEach()` method?

Return from lambda forEach() in java

I have a query that returns an anonymous type and the query is in a method. How do you write this:

    public &quot;TheAnonymousType&quot; TheMethod(SomeParameter)
    {
      using (MyDC TheDC = new MyDC())
      {
         var TheQueryFromDB = (....
                               select new { SomeVariable = ....,
                                            AnotherVariable = ....}
                               ).ToList();

          return &quot;TheAnonymousType&quot;;
        }
    }



Returning anonymous type in C#

**UPDATE**: PHP 7.4 now [does support covariance and contravariance][1] which addresses the major issue raised in this question.  

----------

I have run into something of an issue with using return type hinting in PHP 7.  My understanding is that hinting `: self` means that you intend for an implementing class to return itself.  Therefore I used `: self` in my interfaces to indicate that, but when I tried to actually implement the interface I got compatibility errors.  

The following is a simple demonstration of the issue I&#39;ve run into: 

    interface iFoo
    {
    	public function bar (string $baz) : self;
    }
    
    class Foo implements iFoo
    {
    	
    	public function bar (string $baz) : self
    	{
    		echo $baz . PHP_EOL;
    		return $this;
    	}
    }
    
    (new Foo ()) -&gt; bar (&quot;Fred&quot;) 
    	-&gt; bar (&quot;Wilma&quot;) 
    	-&gt; bar (&quot;Barney&quot;) 
    	-&gt; bar (&quot;Betty&quot;);

The expected output was: 

&gt; Fred
&gt; Wilma
&gt; Barney
&gt; Betty

What I actually get is: 

&gt; PHP Fatal error:  Declaration of Foo::bar(int $baz): Foo must be compatible with iFoo::bar(int $baz): iFoo in test.php on line 7

The thing is Foo is an implementation of iFoo, so as far as I can tell the implementation should be perfectly compatible with the given interface.  I could presumably fix this issue by changing either the interface or the implementing class (or both) to return hint the interface by name instead of using `self`, but my understanding is that semantically `self` means &quot;return the instance of the class you just called the method on&quot;.  Therefore changing it to the interface would mean in theory that I could return any instance of something that implements the interface when my intent is for the invoked instance is what will be returned.  

Is this an oversight in PHP or is this a deliberate design decision?  If it&#39;s the former is there any chance of seeing it fixed in PHP 7.1?  If not then what is the correct way of return hinting that your interface expects you to return the instance you just called the method on for chaining?  


  [1]: https://www.php.net/manual/en/language.oop5.variance.php

PHP 7 interfaces, return type hinting and self

I have a function in python that can either return a `bool` or a `list`. Is there a way to specify the return types using type hints?

For example, is this the correct way to do it?

    def foo(id) -&gt; list or bool:
        ...

How to specify multiple return types using type-hints

Can two Java methods have the **same name** with different **return type**? The return type of the methods are different and they are declared with the same method&#39;s name.

Is that allowed?

Can two Java methods have same name with different return types?

I am implementing a `ResponseHandler` for the apache HttpClient package, like so:

    new ResponseHandler&lt;int&gt;() {
        public int handleResponse(...) {
            // ... code ...
            return 0;
        }
    }

but I&#39;d like for the `handleResponse` function to return nothing, i.e. `void`. Is this possible? The following does not compile, since `void` is not a valid Java type:

    new ResponseHandler&lt;void&gt;() {
            public void handleResponse(...) {
                // ... code ...
            }
    }

I suppose I could replace `void` with `Void` to return a `Void` object, but that&#39;s not really what I want. **Question**: is it possible to organize this callback situation in such a way that I can return `void` from `handleResponse`?

Java generics void/Void types

Is it possible for an inherited class to implement a virtual function with a different return type (not using a template as return)?



C++ virtual function return type

What I understand is that this shouldn&#39;t be done, but I believe I&#39;ve seen examples that do something like this (note code is not necessarily syntactically correct but the idea is there)

    typedef struct{
        int a,b;
    }mystruct;

And then here&#39;s a function

    mystruct func(int c, int d){
        mystruct retval;
        retval.a = c;
        retval.b = d;
        return retval;
    }

I understood that we should always return a pointer to a malloc&#39;ed struct if we want to do something like this, but I&#39;m positive I&#39;ve seen examples that do something like this. Is this correct? Personally I always either return a pointer to a malloc&#39;ed struct or just do a pass by reference to the function and modify the values there. (Because my understanding is that once the scope of the function is over, whatever stack was used to allocate the structure can be overwritten).

Let&#39;s add a second part to the question: Does this vary by compiler? If it does, then what is the behavior for the latest versions of compilers for desktops: gcc, g++ and Visual Studio?

Thoughts on the matter?


Is it safe to return a struct in C or C++?

I have the following enum:
    
    public enum Urgency {
        VeryHigh = 1,
        High     = 2,
        Routine  = 4
    }

I can fetch an **enum &quot;value&quot; as string** like this:
    
    ((int)Urgency.Routine).ToString() // returns &quot;4&quot;  

Note: This is different from:

    Urgency.Routine.ToString() // returns &quot;Routine&quot;
    (int)Urgency.Routine       // returns 4

Is there a way I can create an extension class, or a static utliity class, that would provide some syntactical sugar? :)

C# numeric enum value as string

Is there a good reason that the [Collections.list()](http://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#list(java.util.Enumeration)) method in the `java.utils` package returns an `ArrayList&lt;T&gt;` instead of `List&lt;T&gt;`?

Obviously an `ArrayList` is a `List`, but I&#39;m under the impression that it&#39;s generally good practice to return the interface type instead of implementation type.

Why does Enumeration get converted to ArrayList and not List in java.utils?

I want to write an asynchronous method that returns a [`CompletableFuture`][1]. The only purpose of the future is to track when the method is complete, not its result. Would it be better to return `CompletableFuture&lt;Void&gt;` or `CompletableFuture&lt;?&gt;`? Is there a reason to prefer one or the other, or are they interchangeable?

* [`CompletableFuture`][1] itself returns `CompletableFuture&lt;Void&gt;` from many of its methods.
* `java.nio` has a `Future&lt;Void&gt;` in [`AsynchronousSocketChannel`][4]: `Future&lt;Void&gt; connect(SocketAddress remote)`.
* On the other hand, `java.util.concurrent` classes like [`ExecutorService`][2] and [`ScheduledExecutorService`][3] return `Future&lt;?&gt;`: for instance, with `Future&lt;?&gt; submit(Runnable task)`.

Note that I&#39;m only asking about return types, not parameter lists, variable declarations, or other contexts.

[1]: http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html
[2]: http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html
[3]: http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html
[4]: http://docs.oracle.com/javase/8/docs/api/java/nio/channels/AsynchronousSocketChannel.html

Return CompletableFuture&lt;Void&gt; or CompletableFuture&lt;?&gt;?

What if I write return statement in constructor? Is it standard conformant?

    struct A
    { 
         A() { return; } 
    };

The above code compiles fine, without any error at [ideone][1]. But the following code doesn&#39;t:

    struct A
    { 
       A() { return 100; } 
    };

It gives this error at [ideone][2]:

&gt;error: returning a value from a constructor

I understand that returning value from constructor doesn&#39;t make sense at all, because it doesn&#39;t *explicitly* mention return type, and we cannot store the returned value after all. But I&#39;m curious to know :

- Which statement from the C++ Standard allows the first example  but forbids the second one? Is there any *explicit* statement?
- Is the return *type* in the first example `void`? 
- Is there any *implicit* return type at all?

[1]:http://www.ideone.com/fmpsg
[2]:http://www.ideone.com/50kxf



All Return Type Solutions on Gang of Coders

Total of 27 Return Type Solutions

Why can't I explicitly return void from a method?