A modern programming language that makes developers happier.

kotlinlang

what is the type of this object `object SomeObject` ? like by default without appending any type

objects are singletons so I guess SomeObject is the type?

In Kotlin `Any` is the super-type, much like `Object` in Java.

e.g.

`public final class SomeObject` to be exact

```object SomeObject {
    
}

fun main(){
    when(SomeObject) {
        is Any -&gt; println("Any")
        else -&gt; println("some other type")
    }

}```

&gt; The root of the Kotlin class hierarchy. Every Kotlin class has <https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/index.html#kotlin.Any|Any> as a superclass.

right right, sorry i could’ve just tried that, yes makes sense that it’s Any

everything is Any. I could say Int is Any. I'm not sure if Any is the answer you're looking for

it is, cause the next topic I’m reading about was that “you could give objects a type”, and I thought “oh, but what if I didn’t, what type would it be”

in your example (an object) you are defining a type _and_ creating a singleton instance of it.

in the case of not declaring a super-type, the default is `Any`
These are equivalent:
```object SomeObject
object SomeObject : Any```

of course SomeObject is an instance of SomeObject.

but you cannot say `object AnotherOne: SomeObject`

aha, so it *is* a type, you can have a list of SomeObject, ok

correct.  If you want to mix in inheritance you can define a super-class, or implement an interface.
```abstract class BaseClass
object SomeObject : BaseClass() {
    
}
object AnotherOne : BaseClass() {
    
}```

Regarding the when statement, in Kotlin, when statements are short-circuiting. Everything is an instance of Any, so when that branch evaluates to true, it stops checking the others. Running println(SomeObject is SomeObject) prints true, as would is Any.

that’s correct.  the checks are run in order.  the goal was to demonstrate that SomeObject is an instance of Any.

&gt; it is, cause the next topic I’m reading about was that “you could give objects a type”, and I thought “oh, but what if I didn’t, what type would it be”
The statement “you could give objects a type” can be misleading. If by “objects” they mean instances of things declared using the `object` keyword, then it's misleading because all such objects already _have_ a type. You can give them a _super class type_ but not an actual object type. On the other hand, if by “objects” they mean instances of a class, then of course you could give them a type as in `val myObject: MyClass = foo()`.