A modern programming language that makes developers happier.

kotlinlang

image.png

Is this the correct behavior? Only is working inside functions

Running code outside of functions is not allowed.

The only things you can do are function / class declarations.

However, this is allowed:

```object Hello {
  val x = "Hello"
}

fun main() {
  Hello.x // whatever
}```

It's not about code outside of functions. It works the same when you put `hello.x` inside `main()`. It's strange for me as well.

Ah, then there's a second problem, but I won't just give the answer to it. What's the type of the `hello` variable?

It's `Any` in the second case and `&lt;anonymous object : Any&gt;` in the first (working) one.

I think this behavior is documented here:
<https://kotlinlang.org/docs/object-declarations.html#using-anonymous-objects-as-return-and-value-types>

But it's for sure not clear for me :wink:

that is a scratch file, I can run code there <@UFGCACPE0>

Yep, the variable's type is `Any`, and `Any` doesn't have an `x` attribute.

The version I wrote above will work, because I'm actually declaring a new type (with an `x` attribute)

Enable type hints to understand these cases better

well, my use case is to have it public, so it isn't working for me so, but I would like compiler could resolve it even if it is public..

Check the version I sent, it will work no matter if it's public or not.

I know that works, but I want trying to avoid that, having an unnecessary public object in the namespace

<@UFT11FKSP> yep, here: `When an anonymous object is used as a type of a local or private but not inline declaration (function or property), all its members are accessible via this function or property`

You want to:
• provide the caller with an object that has an x attribute that they can use
• not declare the object
You can't have both

just as a sidenote: you could also make your anonymous object implement an interface. But as long as that interface isn't used anywhere else, you don't gain much from that