test(1) results in “12.0” test(2) results in “13.0" Ran in Scratch file of IntelliJ, hence no

println

What am I missing? I would have expected the val to require an initial value, and complain if it’s assigned, but it appears not.

import org.apache.logging.log4j.core.Filter; import org.apache.logging.log4j.core.Layout; import org.apache.logging.log4j.core.LogEvent; import org.apache.logging.log4j.core.appender.AbstractAppender; import org.apache.logging.log4j.core.appender.AppenderLoggingException; import org.apache.logging.log4j.core.config.plugins.Plugin; import org.apache.logging.log4j.core.config.plugins.PluginAttribute; import org.apache.logging.log4j.core.config.plugins.PluginElement; import org.apache.logging.log4j.core.config.plugins.PluginFactory; import org.apache.logging.log4j.core.layout.PatternLayout; import java.io.Serializable; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * <h2>AnsiConsoleAppender</h2> * * <h3>notes</h3> * <li>class name need not match the @Plugin name</li> * <h3>more<h3/> * <li><a href="https://stackoverflow.com/a/24220688/270143">How to Create a Custom Appender in log4j2?</a></li> */ @Plugin(name="AnsiConsoleAppender", category="Core", elementType="appender", printObject=true) public final class AnsiConsoleAppender extends AbstractAppender { private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); private final Lock readLock = rwLock.readLock(); protected AnsiConsoleAppender(String name, Filter filter, Layout<? extends Serializable> layout, final boolean ignoreExceptions) { super(name, filter, layout, ignoreExceptions); } // The append method is where the appender does the work. // Given a log event, you are free to do with it what you want. // This example demonstrates: // 1. Concurrency: this method may be called by multiple threads concurrently // 2. How to use layouts // 3. Error handling //@Override public void append(LogEvent event) { try { final byte[] bytes = getLayout().toByteArray(event); System.out.write("YO: ".getBytes()); System.out.write(bytes); } catch (Exception ex) { if (!ignoreExceptions()) throw new AppenderLoggingException(ex); } } // Your custom appender needs to declare a factory method // annotated with

@PluginFactory

. Log4j will parse the configuration // and call this factory method to construct an appender instance with // the configured attributes. @PluginFactory public static AnsiConsoleAppender createAppender( @PluginAttribute("name") String name, @PluginElement("Layout") Layout<? extends Serializable> layout, @PluginElement("Filter") final Filter filter, @PluginAttribute("otherAttribute") String otherAttribute) { if (name == null) { LOGGER.error("No name provided for AnsiConsoleAppenderImpl"); return null; } if (layout == null) { layout = PatternLayout.createDefaultLayout(); } return new AnsiConsoleAppender(name, filter, layout, true); } }

Also, the calls are very similar, just they act on different domains (think CRUD account, CRUD message, etc) -- does it even make sense to break it up to AccountCrud-er, etc to keep the interface file shorter?

What's better (faster? more memory efficient?) when creating mutable maps where the insertion order doesn't matter? Use

mutableMapOf()

and

toMutableMap()

which use

LinkedHashMap

or instead

hashMapOf()

and

HashMap(other)

?

anyone know how to migrate this code from https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md ?

fun <T> future(context: CoroutineContext = CommonPool, block: suspend () -> T): CompletableFuture<T> =
        CompletableFutureCoroutine<T>(context).also { block.startCoroutine(completion = it) }

class CompletableFutureCoroutine<T>(override val context: CoroutineContext) : CompletableFuture<T>(), Continuation<T> {
    override fun resumeWith(result: Result<T>) {
        result
                .onSuccess { complete(it) }
                .onFailure { completeExceptionally(it) }
    }
}
suspend fun <T> CompletableFuture<T>.await(): T =
        suspendCoroutine { cont: Continuation<T> ->
            whenComplete { result, exception ->
                if (exception == null) // the future has been completed normally
                    cont.resume(result)
                else // the future has completed with an exception
                    cont.resumeWithException(exception)
            }
        }

I mean, is it correct apart from the

CommonPool

part? should I just replace

CommonPool

with

EmptyCoroutineContext

?

Is it worth it to provide "lesser scoped" interface of the same instance, if its be "hacked" via casting?

interface ReadFooRepository {
	fun getFoos() : List<Foo>
}

class FooRepository : ReadFooRepository {
	override fun getFoos() ...
	fun saveFoo(foo: Foo) ...
}

@provides @singleton fooRepository() : FooRepository = FooRepository()
@provides readFooRepository(fooRepository: FooRepository) : ReadFooRepository = fooRepository

class FooViewModel(private val readFooRepository : ReadFooRepository)
 ... only consume values

is it bad or good practice to use global variables representing "services", like this one:

val esClient: RestHighLevelClient by lazy {
    createEsClient(
        hosts = arrayOf(HttpHost("localhost", 9200, "http"))
    )
}

Coroutines are incredibly complex, as I have learned over the past week or so. As part of a movie/tv app I am writing, I faced the need to fetch millions of lines of JSON data for a half dozen or so lists. This is my second take at a daily task to update these records in the app. Critique’s much appreciated:

Just looking for feedback on this Presenter abstract that I’ve recently converted to Kotlin and tweaked. https://gist.github.com/nukeforum/8bc40d330adb9558d2060f08ac87b0e6

use destructing on val comments in line 5 to avoid .first and .second too

Any ideas how to solve this type inference issue? I would like to return a generic anonymous function whose type is determined by the outer function, without having to specify the type explicitly at the call site: https://stackoverflow.com/q/54799122/1772342

Is there a way for me to make

invoke()

inlined or otherwise achieve what I’m attempting in

doWork()

?

Wonder if there is a nice way to make this shorter

protected fun prepareStandardSemaphores(device: VulkanDevice): ConcurrentHashMap<StandardSemaphores, VkSemaphore_Array> {
        val map = ConcurrentHashMap<StandardSemaphores, VkSemaphore_Array>()
        StandardSemaphores.values().forEach {
            map[it] = VkSemaphore_Array(swapchain.images.size) {
                vkDev.createSemaphore(semaphoreCreateInfo) 
            }
        }
        return map
    }

This looks non scalable to me

fun foo(bar: List<Int>): Int {
    check(bar.isNotEmpty())

    return bar.max()!! / 2
}

How would you deal with

max

returning a nullable value, other than

!!

? Does it bother you?

what should happen when max returns a null value?

how can I catch it while still keeping the method signature and just bouncing back succesfully? I am ok with ignoring this exception

This is probably not ideal… open to any feedback

sharedElements?.let { thisSharedElements -> 
  names?.let { thisNames ->
    viewHolder?.let { thisViewHolder ->
      thisSharedElements[thisNames[0]] = thisViewHolder.itemView
    }
  }
}

wonder what people think about this - sometimes i think the elvis operator can be a little confusing, especially in combination with other operators - using an orElse function to specify a default

fun <T> T?.orElse(default: T) = this ?: default

for example i have a when statement like this

return when {
           foo.blah?.someNullableFlag ?: false -> true
}

vs

return when {
           foo.blah?.someNullableFlag.orElse(false) -> true
}

called like this

incomeTypes.forEach {
            val incomeType = IncomeType.valueOf(it, IncomeType.UNKNOWN)

Need to return an immutable variable number of items from a function. Should I return a

List<T>

or

Array<T>

?

how may I rewrite this more functional?

// Request several formats, the first found will be used
            for (request in requestFormats)
                for (avail in availFormat)
                    if (avail.format == request && avail.colorSpace == requestColorSpace)
                        return avail
            
            // If none of the requested image formats could be found, use the first available
            return availFormat[0]

In this case I’d say you’re right. I’d use a sealed class if some field would be always null for

PeriodType.Past

for example, but if everything is the same, enum should be fine

I'm not sure this is the right place to ask but I'm struggling a bit with API design. I've posted this on stack exchange as well: https://softwareengineering.stackexchange.com/questions/392156/designing-a-builder-as-a-compile-time-state-machine

can this be converted to some functional-programming construct?

int insertionIndex = 0;
                        for (insertionIndex = 0; insertionIndex < activeActionSetsList.Count; insertionIndex++) {
                            if (activeActionSetsList[insertionIndex].nPriority > activeSet.nPriority)
                                break;
                        }

Anyone know of a collection version of

Map<K, V>.putIfAbsent(key: K, value: V)

?

putAll

overrides existing values sadly.

my first sketch is to have

DoBlendRoutine

as a suspend function and

blendRoutine

as a

Job?

, however I'm not sure about the

StartCoroutine

part.. I think I shall directly

launch { }

at that point