You can get a function instance for a constructor by simply using `::ClassName`, as if it were a factory function. 

I have a spark streaming application which produces a dataset for every minute.
I need to save/overwrite the results of the processed data.

When I tried to overwrite the dataset org.apache.hadoop.mapred.FileAlreadyExistsException stops the execution.

I set the Spark property `set(&quot;spark.files.overwrite&quot;,&quot;true&quot;)` , but there is no luck.

How to overwrite or Predelete the files from spark?

How to overwrite the output directory in spark

Getting 

&gt; Code signing is required for product type &#39;Unit Test Bundle&#39; in SDK
&gt; &#39;iOS 8.0&#39;

My app target is code signing just fine - but my test target is not.  I bought a new computer, created a new development certificate from the computer, updated the provisioning profile accordingly, installed both, but can&#39;t get past this code signing error.

Any way of wiping all certs/profiles locally so I can reinstall?

Probably some kind of bug.

Code signing is required for product type Unit Test Bundle in SDK iOS 8.0

In Java we have the `Class::new` syntax for constructor references. I know, there are callable references for methods, but how about constructors? A typical use case for me would be factories.

Are there constructor references in Kotlin?

<p>In Java we have the <code>Class::new</code> syntax for constructor references. I know, there are callable references for methods, but how about constructors? A typical use case for me would be factories.</p>


When I tried to write an equivalent of a Java `try`-with-resources code in Kotlin, it didn&#39;t work for me.

I tried different variations of the following:

    try (writer = OutputStreamWriter(r.getOutputStream())) {
        // ...
    }

But neither works.

Does anyone know what should be used instead?
Apparently Kotlin grammar [doesn&#39;t have definition][1] for such a construct, but maybe I&#39;m missing something. It defines grammar for try block as follows:

    try : &quot;try&quot; block catchBlock* finallyBlock?;



  [1]: http://kotlinlang.org/docs/reference/grammar.html

Try-with-resources in Kotlin

I am in the processing of learning Kotlin and ran into a problem I couldn&#39;t figure out.
I would like to extend the Java class `RuntimeException` in Kotlin and be able to use any one of three of its constructors, in different circumstances (based on what info I have at the time I want to throw an exception). In java my class would look like this:

    public class PhotoLibException extends RuntimeException {
    
        public PhotoLibException(String message, RuntimeException ex) {
            super(message, ex);
        }
    
        public PhotoLibException(String message) {
            super(message);
        }
    
        public PhotoLibException(RuntimeException ex) {
            super(ex);
        }
    }
When I try to do this in Kotlin, I used this answer as a guide: https://stackoverflow.com/questions/19299525/kotlin-secondary-constructor however, I had a problem trying to figure out how to invoke the appropriate super constructor correctly. For example, using functions seemed to be a good approach, like this:

    fun PhotoLibException(message: String): PhotoLibException {
        val ex = null
        return PhotoLibException(message, ex)
    }
    
    fun PhotoLibException(ex: Exception): PhotoLibException {
        val message = &quot;&quot;
        return PhotoLibException(message, ex)
    }
    
    class PhotoLibException(message: String, ex: Exception?): RuntimeException(message, ex) {
    }
However, in this Kotlin example above, I am always invoking the super constructor with two args, and not invoking the constructor most appropriate to the situation. So what I have above works, but doesn&#39;t do exactly what it would do in Java where a different constructor is invoked in each situation.
I also tried instantiating a new RuntimeException inside each fun above and casting it to PhotoLibException, but I wasn&#39;t allowed to do that.

Can anyone suggest how I would do this correctly in Kotlin?

How to extend a class that has multiple constructors in Kotlin?

How do you define a static extension method in Kotlin? Is this even possible? I currently have an extension method as shown below.

    public fun Uber.doMagic(context: Context) {
        // ...
    }

The above extension can be invoked on an instance.

    uberInstance.doMagic(context) // Instance method

but how do I make it static method like shown below.

    Uber.doMagic(context)         // Static or class method


Static extension methods in Kotlin

Is it possible to access extension functions from Java code?

I defined the extension function in a Kotlin file.

    package com.test.extensions
    
    import com.test.model.MyModel
    
    /**
     *
     */
    public fun MyModel.bar(): Int {
        return this.name.length()
    }

Where `MyModel` is a (generated) java class.
Now, I wanted to access it in my normal java code:

    MyModel model = new MyModel();
    model.bar();

However, that doesn&#39;t work. **The IDE won&#39;t recognize the `bar()` method and compilation fails.** 

What does work is using with a static function from kotlin:

    public fun bar(): Int {
       return 2*2
    }

by using `import com.test.extensions.ExtensionsPackage` so my IDE seems to be configured correctly.

I searched through the whole Java-interop file from the kotlin docs and also googled a lot, but I couldn&#39;t find it.

What am I doing wrong? Is this even possible?

Accessing Kotlin extension functions from Java

I have an enum with some instances `Foo` and `Bar`.  If I have a string `&quot;Foo&quot;`, how can I instantiate a `Foo` enum from that?  In C# it would be `Enum.Parse(...)`, is there an equivalent in Kotlin?

Currently, the best I have found is to create a factory that switches on all possible strings, but that is error prone and performs poorly for large enumerations.

How do I create an enum from a string in Kotlin?

Why doesn&#39;t the first of the following examples work?

 - `run(R::new);` method `R.run` is not called.
 - `run(new R());` method `R.run` **is** called.

Both examples are compiled-able.

    public class ConstructorRefVsNew {

      public static void main(String[] args) {
          new ConstructorRefVsNew().run(R::new);
          System.out.println(&quot;-----------------------&quot;);
          new ConstructorRefVsNew().run(new R());
      }

      void run(Runnable r) {
          r.run();
      }

      static class R implements Runnable {
  
          R() {
              System.out.println(&quot;R constructor runs&quot;);
          }

          @Override
          public void run() {
              System.out.println(&quot;R.run runs&quot;);
          }
      }
    }

The output is:

      R constructor runs
      -----------------------
      R constructor runs
      R.run runs

In the first example, the `R` constructor is called, it returns lambda (which is not object):

[![](https://i.stack.imgur.com/A6prZ.png)](https://i.stack.imgur.com/A6prZ.png)

But then how is it possible, that the example is compiled successfully?

Content Type	Original Author	Original Content on Stackoverflow
Question	Kirill Rakhman	View Question on Stackoverflow
Solution 1 - Kotlin	Ilya Ryzhenkov	View Answer on Stackoverflow

Are there constructor references in Kotlin?

Kotlin Problem Overview

Kotlin Solutions

Solution 1 - Kotlin

Code signing is required for product type Unit Test Bundle in SDK iOS 8.0

How to overwrite the output directory in spark

Attributions