Is there a way to do something like the following:

fun <T: Somethingable> String.buildSomething(): T {
	return T.buildSomethingFromString(this)
}

The only way to get buildSomethingFromString is to have a interface Somethingable have a default implementation in a companion object. But then I lose compile time checking for overriding implementation on T. I thought I could be specific on the extension for each concrete impl, but I can’t redefine String.buildSomething(): Impl1 and String.buildSomething(): Impl2 without changing the name.

where is the instance of T meant to come from?

T is any Jvm static Somethingable

-.kt

The type system can't completely CYA here for obvious reasons with arbitrary srings

Yeah, let me play with it. I was trying to provide the impl inside of Person and Alien…. but I could probably work this in the bounds of my parser.

inline fun <reified T : Mammal> String.buildSomething(): T { val creationCall = T::class.companionObject...notsurehere-google-from-here-find-the-function-call return ((invoke creationCall) as T) }

there's reflection if you wanted to go this route... you'd need to get the companion object, find the creation method, invoke it and cast to T and return, the above obviously doesnt work but its something to explore

without the reified type parameter you can't get access to the class etc..

But it doesn’t seem to come up for me when using T::class

is it reified?

And also is similar to apply?

oh, i see the difference now

They're all similar.

apply

and

run

use

this

instead of passing a parameter.

let

and

run

return the lambda's return value.

apply

and

also

always return

this

apply

you should use for configuring the receiver-object (eg. a builder like pattern)

also

is for ’side-effects`. Both

apply

and

also

return the receiver on which they were called.

let

is often used for handling nullable properties to do stuff when it’s not null:

myProperty?.let { .... code... }

.

with

and

run

are often used to avoid writing/coding the same receiver over and over again (you can often refactor them into proper private extension functions) or for calling an instance method with a receiver from outside the class of that instance (calling an instance method given a certain context).

run

is better for method chains. The name is quite misleading in some scenarios though.

Caused by: java.time.format.DateTimeParseException: Text '2019-02-25T164140.233' could not be parsed: Conflict found: HourOfDay 16 differs from HourOfDay 0 while resolving SecondOfDay

what does that mean?

I'm trying to format using : LocalDateTime.parse(value, DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HHmmss'.'A"))

hmmm looks like I don't really need that… LocalDateTime.parse(value.replace(" ","T") was enough. But I still take an explanation if someone has one

A is “milli of day” (hence 233 had hour 0)— you probably wanted S “fraction of second”

(At least I think — looking at the docs now it’s less than obvious!)

You’d want SSS for millis

yes that's what I wanted