The app I'm working on uses Retrofit 2, so you know there's an interface with methods for every kind of request. I'm trying to implement a centralized request queue of some sort to avoid duplicate requests for the same kind of request. Any suggestions/solutions for this approach?

How to go about making requests typesafe with that queue?

Jake will have better thoughts about this. Ask this question in #C0B8M7BUY. But, do make sure your requests are idempotent, and this is normally a non-issue.

Thank you, I asked this here because I thought #C0B8M7BUY is meant for kotlin + android related questions, which mine isn't.

@debug In general, yeah, but Jake will see it if you post in #C0B8M7BUY haha. :)

@carlbenson has left the channel

crossinline

wat

@jkbbwr: https://kotlinlang.org/docs/reference/inline-functions.html#non-local-returns

Gosh damn

If interface is declared in Kotlin, SAM conversions are disabled. Also, if an interface has more than one member, obviously.

If you are doing it in Kotlin, you’d better use proper functional types. In 1.1 you can also make a typealias for a such a type.

However, I must admit there are cases when Kotlin interface acting as a SAM would be preferable.

thanks @irus, I'll do

I'd like first to finish the porting and add some coverage testing

anyway, thanks for adding them 👋

Great, thanks!

Convert Java file to Kotlin -> Kotlin threw uncaught exception

static String pairsToString(Collection<IntPair> pairs) {
        StringBuilder builder = new StringBuilder(4 * pairs.size());
        for (Iterator<IntPair> iter = pairs.iterator(); iter.hasNext(); ) {
            IntPair pair = iter.next();
            builder.append(pair.getFirst()).append(' ').append(pair.getSecond());
            if (iter.hasNext()) {
                builder.append(',');
            }
        }
        return builder.toString();
    }

@semoro ^^

@miha-x64 could not reproduce with latest dev kotlin plugin. Which version of kotlin-plugin are you using? Also, you converting with copy-paste or with Code -> Convert Java To Kotlin?

https://github.com/yegor256/eo

It's the future of OOP

Interesting that reflection is in their 'do not tolerate' list, but I can see why, especially if that forces explicit exposure of discoverable functionality...

Constants is a weirder one to justify, mostly due to the importance of locality for some types of constants.

I guess that goes along with 'statics' though

This guy is really opinionated about OOP, but often there are pretty good observations: http://www.yegor256.com/

Dot’t forget about his book https://www.amazon.com/gp/product/1519166915 😉

I'm guessing this is more Smalltalk-inspired?

Annotation-less AOP? That could be good.

The way this fleshes out... it's standard FP framed around protocols...

Some of the composability / delegation parts feel like the 'stamp' idea I saw around JS