Implicit `Unit` return type:

    def f() {println(&quot;ABC&quot;)}

Explicit `Unit` return type:

    def g(): Unit = {println(&quot;ABC&quot;)}

Return type inferred from the last method expression, still `Unit` because this is the type of `println`, but confusing:

    def h() = println(&quot;ABC&quot;)

All the methods above are equivalent. I would prefer `f()` because the lack of `=` operator after method signature alone is enough for me. Use explicit `: Unit` when you want to extra document the method. The last form is confusing and actually treated as a warning in [tag:intellij-idea].

The `=` operator is crucial. If it is present it means: &quot;*please return whatever the last statement returns*&quot; in method body. Obviously you cannot use this syntax for `abstract` methods. If it is not, `Unit` is assumed.

The special syntax for procedures (methods returning _Unit_) was a mistake. Don&#39;t use it. It is confusing and dangerous for beginners with a Java/C(++) background. And it is a unnecessary special treatment. Always use the equal sign, with and without type inference (the latter should only be used for private members):

    def foo(): Unit = someCodeReturningUnit()
    
    private def bar() = someCodeReturningUnit()

The Scala community is divided about it. On the one hand, not using explicit return types means you can easily forget the `=` sign, which results in errors that are often annoying to track. On the other hand, `Unit`-returning methods having a different syntax puts them in a separate category, which pleases some people.

Personally, I&#39;d rather this syntax would go away -- the errors resulting from missing `=` _are_ annoying to track. But it&#39;s not even deprecated, so I&#39;d rather take advantage of it than just suffer the problems of its existence.

So, use whatever you wish. There&#39;s going to be people criticizing your choice either way, and people praising it either way.

Why does this typecheck:

    runST $ return $ True

While the following does not:

    runST . return $ True

GHCI complains:

    Couldn&#39;t match expected type `forall s. ST s c0&#39;
                with actual type `m0 a0&#39;
    Expected type: a0 -&gt; forall s. ST s c0
      Actual type: a0 -&gt; m0 a0
    In the second argument of `(.)&#39;, namely `return&#39;
    In the expression: runST . return

runST and function composition

*Using JPA 2 with EclipseLink implementation.*

I&#39;m trying to build a dynamic query which should bring me some records persisted after a given date.

    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery&lt;Event&gt; criteria = builder.createQuery(Event.class);
    Root&lt;Event&gt; root = criteria.from(Event.class);
    criteria.select(root);
    criteria.distinct(true);
    List&lt;Predicate&gt; predicates = new ArrayList&lt;Predicate&gt;();
    //...
    if (dateLimit != null){
        ParameterExpression&lt;Date&gt; param = builder.parameter(Date.class, &quot;dateLimit&quot;);
        predicates.add(builder.lessThanOrEqualTo(root.get(&quot;dateCreated&quot;), param));
    }

`lessThanOrEqualTo()` and `le()` are the only two methods in the API which look like may help me in this case. This warning is thrown by the eclipse though:

    Bound mismatch: The generic method lessThanOrEqualTo(Expression&lt;? extends Y&gt;, Expression&lt;? extends Y&gt;)
    of type CriteriaBuilder is not applicable for the arguments (Path&lt;Object&gt;, ParameterExpression&lt;Date&gt;).
    The inferred type Object is not a valid substitute for the bounded parameter
    &lt;Y extends Comparable&lt;? super Y&gt;&gt;

I can imagine that I&#39;m not taking the correct approach for this problem but I can&#39;t find anywhere some tips or pointers for a possible solution.


Compare Date entities in JPA Criteria API

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?

<p>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?</p>
<p>Can anyone please advise?</p>


So far implicit parameters in Scala do not look good for me -- it is too close to global variables, however since Scala seems like rather strict language I start doubting in my own opinion :-).

**Question:** could you show a real-life (or close) good example when implicit parameters really work. IOW: something more serious than `showPrompt`, that would justify such language design.

Or contrary -- could you show reliable language design (can be imaginary) that would make implicit not neccessary. I think that even no mechanism is better than implicits because code is clearer and there is no guessing.

*Please note, I am asking about parameters, not implicit functions (conversions)!*

# Updates

## Global variables

Thank you for all great answers. Maybe I clarify my &quot;global variables&quot; objection. Consider such function:

    max(x : Int,y : Int) : Int

you call it 

    max(5,6);

you could (!) do it like this:

    max(x:5,y:6);

  but in my eyes `implicits` works like this:

    x = 5;
    y = 6;
    max()

it is not very different from such construct (PHP-like)

    max() : Int
    {
      global x : Int;
      global y : Int;
      ...
    }

## Derek&#39;s answer

This is great example, however if you can think of as flexible usage of sending message not using `implicit` please post an counter-example. I am really curious about purity in language design ;-).

Good example of implicit parameter in Scala?

EDIT: I keep getting upvotes here. Just for the record, I no longer think this is important. I haven&#39;t needed it since I posted it.

I would like to do following in Scala ...

    def save(srcPath: String, destPath: String) {
        if (!destPath.endsWith(&#39;/&#39;))
            destPath += &#39;/&#39;
        // do something
    }

... but I can&#39;t beacuse `destPath` is a val. Is there any way to declare `destPath` as var?

Note: there are similar questions but in all of them OP just wanted to modify array.

Please do not advise following:

&gt; Mutating the input parameters is often seen as bad style and makes it
&gt; harder to reason about code.

I think it&#39;s valid in imperative programming (Scala allows both, right?) and adding something like `tmpDestPath` would just add clutter.

EDIT: Don&#39;t misunderstand. I know that strings aren&#39;t mutable and I don&#39;t want a reference to reference because I don&#39;t want to modify data of caller. I just want to modify local reference to string that caller gave me with my string (eg. orig + &#39;/&#39;). I want to modify that value only in scope of current method. Look, this is perfectly valid in Java:

    void printPlusOne(int i) {
        i++;
        System.out.println(&quot;i is: &quot; + i);
        System.out.println(&quot;and now it&#39;s same: &quot; + i);
    }

I don&#39;t have to create new variable and i don&#39;t have to compute i+1 twice.

Scala - mutable (var) method parameter reference

Suppose that I have a string in scala and I want to try to parse a double out of it.  

I know that, I can just call `toDouble` and then catch the java num format exception if this fails, but is there a cleaner way to do this?  For example if there was a `parseDouble` function that returned `Option[Double]` this would qualify.  

I don&#39;t want to put this in my own code if it already exists in the standard library and I am just looking for it in the wrong place.

Thanks for any help you can provide.

How to find if a Scala String is parseable as a Double or not?

I&#39;m trying to search a scala collection for an item in a list that matches some predicate. I don&#39;t necessarily need the return value, just testing if the list contains it.

In Java, I might do something like:

    for ( Object item : collection ) {
        if ( condition1(item) &amp;&amp; condition2(item) ) {
           return true;
        }
    }
    return false;

In Groovy, I can do something like:

    return collection.find { condition1(it) &amp;&amp; condition2(it) } != null

What&#39;s the idiomatic way to do this in Scala? I could of course convert the Java loop style to Scala, but I feel like there&#39;s a more functional way to do this.

Finding an item that matches predicate in Scala

I wonder how to get a class object for an object type in Scala. Ok, that is a mouth full because of the double meaning for object. So here an example which will fail:

    object Main
    {
       private [this] val TAG = classOf [Main].getName;
    } // Main

If `Main` was class it works perfectly. Any ideas? 

How the get the classOf for a scala object type

I have a few static util methods in my project, some of them just pass or throw an exception. There are a lot of examples out there on how to mock a static method that has a return type other than void. But how can I mock a static method that returns void to just &quot;`doNothing()`&quot;?

The non-void version uses these lines of codes:

    @PrepareForTest(StaticResource.class)
...

    PowerMockito.mockStatic(StaticResource.class);

...

    Mockito.when(StaticResource.getResource(&quot;string&quot;)).thenReturn(&quot;string&quot;);


However if applied to a `StaticResources` that returns `void`, the compile will complain that `when(T)` is not applicable for void... 

Any ideas?

A workaround would probably be to just have all static methods return some `Boolean` for success but I dislike workarounds.

How do I mock a static method that returns void with PowerMock?

In API

&gt; &quot;The Void class is an uninstantiable placeholder class to hold a
&gt; reference to the Class object representing the Java keyword void.&quot;


1. What is &quot;uninstantiable&quot; place holder class? When will `java.lang.Void` be used? If the class  is &quot;uninstantiable&quot;, what use is it?
2. What is difference between `java.lang.Void` and `void`?

What is the difference between java.lang.Void and void?

What does the following mean : 

    int main(void) {...} 

VS

    int main() {...}

?


I think that `int main() {...}` means that main doesn&#39;t receive any parameters (from command line) , however:

    int main(int argc, char *argv[])

does.

But, what does `int main(void) {...}`  mean? And, what does **void** stand for ?

I&#39;ve looked [here][1] but it&#39;s somehow a different question . 



  [1]: https://stackoverflow.com/questions/636829/difference-between-void-main-and-int-main


Difference between int main() and int main(void)?

Ok, so I have heard different opinions on this subject and just want to make sure I understand it correctly.

## For C++

Declarations `void f();` and `void f(void);` mean precisely the same thing, the function `f` does not take any parameters. Ditto for definitions.

## For C

Declaration `void f(void);` means that `f` does not take any parameters. 

Declaration `void f();` means that function `f` may or may not have parameters, and if it does, we don&#39;t know what kind of parameters those are, or how many there is of them. Note that it is NOT the same as ellipsis, we can&#39;t use `va_list`.

Now here is where things get interesting. 

### Case 1

Declaration:

    void f();

Definition:

    void f(int a, int b, float c)
    {
       //...
    }

### Case 2

Declaration:

    void f();

Definition:

    void f()
    {
       //...
    }

### Question:

What happens at compile time in cases 1 and 2 when we call `f` with the correct arguments, wrong arguments and no arguments at all? What happens at run time?

### Additional question:

If I declare `f` with arguments, but define it without them, will it make a difference? Should I be able to address the arguments from the function body?


Understanding the difference between f() and f(void) in C and C++ once and for all

I&#39;ve just come across someone&#39;s C code that I&#39;m confused as to why it is compiling. There are two points I don&#39;t understand.

1.  The **function prototype** has no parameters compared to the actual function definition. 


2. The parameter in the **function definition** does not have a type.


----------


    #include &lt;stdio.h&gt;

    int func();

    int func(param)
    {
    	return param;
    }

    int main()
    {
    	int bla = func(10);    
    	printf(&quot;%d&quot;, bla);
    }



Why does this work? 
I have tested it in a couple of compilers, and it works fine.


Why does a function with no parameters (compared to the actual function definition) compile?

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++?

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?

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#

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

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.

Content Type	Original Author	Original Content on Stackoverflow
Question	balteo	View Question on Stackoverflow
Solution 1 - Scala	Tomasz Nurkiewicz	View Answer on Stackoverflow
Solution 2 - Scala	Heiko Seeberger	View Answer on Stackoverflow
Solution 3 - Scala	Daniel C. Sobral	View Answer on Stackoverflow

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

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

Solution 2 - Scala

Solution 3 - Scala

Compare Date entities in JPA Criteria API

runST and function composition

Attributions