public val properties for interface does’t do smart casting to the object that were set into them.
There is an option do declare 2 variables. one public interface and one private instance. but I prefer just one
what I wish to have:
class MyClass{
val myObservable: Observable<Unit> = PublishSubject.create<Unit>()
fun foo(){
myObservable.onNext(Unit) // smart casting doesn't work, but should
}
}
what works but involves boilerplate code
class MyClass{
private val myPublisher = PublishSubject.create<Unit>()
val myObservable: Observable<Unit> = myPublisher
fun foo(){
myPublisher.onNext(Unit)
}
}
I what the class to reveal whoever uses it Observable but inside the class use PublishSubject
The same approach can also happen with LiveData where inside the class (ViewModel) you want MutableLiveData but reveal the Activity/Fragment just LiveData
Sorry, but I still do not understand, what you mean. There is a standard pattern in Kotlin where you reveal mutable something inside the class and read-only something outside. Like:
private val _list: MutableList<Int>
val list: List<Int> get() = list
It add another line to the code, but there are not ways around it, because the types are indeed different inside the class and outside.
It force me to double the amount of variables in my class. If smart casting can solve it (as casting should) why shouldn’t we have it? It’s a val param anyways.
There are workaround. Notice I mentioned your solution in my original post. It doesn’t mean we need to do it every single time.
In my class’s functions I’ll have to type the undrscore param and not the regular. I dont like this boilerplate and I believe it can easily be fixed
Simply, what he wants is that to expose the val property as an interface or superclass type (a “general” type if you wish), but then use it in the same code in his class as a property of the actual, declared type.
For example, let’s suppose that he has a val like this:
class MyClass{
val myCharSequence: CharSequence = "this is a string"
fun foo() {
//Note that plus is a function that is defined on the String class, and not the CharSequence interface
println(myCharSequence.plus(" that got plused by another string") //Wouldn't run because it wouldn't be smart casted
}
}
So, in other words, he wants to hide the implementation details of the val so that any outside class can safely use it regardless of what the library decides to use as the actual underlying type while still being able to call any functions that is defined on the actual underlying type without needing to cast because the compiler should be a 100% sure that the var’s type is of that underlying type.
As a temporary solution for now, I think that OP could just cast the val at the start of every function to the type that he wants and then call .also{ preferredNameForCastedVal -> //Code }
I really don’t get what am I missing, why should we do it if it doubles our code?
we know that this will work
val myObservable: Observable<Unit> = PublishSubject.create<Unit>()
fun foo() {
if (myObservable is PublishSubject<Unit>) { // always true because it's a val
myObservable.onNext(Unit)
}
}
don’t you feel it’s more elegant without the redundant “if”
or without having 2 parameters like we both suggested?
private val _observable = PublishSubject.create()
val observable: Observable get() = _observable
Doing this, you can call both internal and external value without effort. It costs you a single line, not doubling the code.
Second, I see a complain, but I do not see a solution. How can you tell which type to use for internal use and which for external use? Won’t it cost the same additional line if you had a syntax to do it? There are several tickets about it in the tracker, but nobody managed to propose more concise syntax than it is now.
you are right, doubles the parameters, not the code. still, I have many of these
I do suggest a solution. smart casting can tell the value real type by scanning the code. if that’s the case, and val property cannot be changed, kotlin should allow us to know the real type inside the class.
