is it possible to define a member to look like it is hidden within another? that is, could i define...

# announcements

[bbaldino]

is it possible to define a member to look like it is hidden within another? that is, could i define a class like:

class Foo {
  var baz: Int
}

such that callers accessed baz by doing Foo.bar.baz ?

[streetsofboston]

Not sure why you’d want this, but this would work:

class Foo {
  var baz: Int
}

val Foo.bar get() = this

Now, you can call val value: Int = myFoo.bar.baz

[bbaldino]

ah that's pretty slick! don't suppose there'd be a way to do it which would make baz only accessible through bar ?

[bbaldino]

the use case is that i've got some properties in Foo that logically would be nested into an inner member, but Foo needs to potentially take action when they're modified (and access Foo data), so was thinking about this as a possible method

[bbaldino]

and an inner class doesn't feel like the right model, conceptually

[streetsofboston]

Then an inner class would be good for this. Why don’t you think it’s right to use an inner class?

[bbaldino]

it feels like this class should be more 'independent' than existing as an inner class, but maybe i'll rethink that.

[streetsofboston]

interface IFoo {
    var baz : Int
}

class Foo {
    private var baz: Int = 8

    val bar : IFoo = object : IFoo {
        override var baz: Int
            get() = [e-mail]
            set(value) { [e-mail] = value }
    }
}

fun main() {
    Foo().bar.baz
}

[bbaldino]

ah that's i think what i was looking for. thanks! i'll weigh that vs the inner class

[streetsofboston]

Or weirder 🙂

interface InnerFoo {
    val bar : Foo
}

class Foo private constructor() {
    companion object {
        operator fun invoke() : InnerFoo = object : InnerFoo {
            override val bar = Foo()
        }
    }

    private var hiddenProp: Int = 0

    var baz : Int = 0
}

fun main() {
    val foo = Foo()
    foo.bar.baz
    foo.bar.baz = 29
}