A modern programming language that makes developers happier.

kotlinlang

I saw some code that defines a function-local `object` that captures a local variable
that's basically a `class`, right? there's no benefit to making it an `object`?

an `object` is an instance of some class (named or not), and you need an instance to capture

e.g.
```fun f(name: String): Any {
    return object {
        override fun toString(): String = name
    }
}```
is roughly equivalent to
```fun f(name: String): Any {
    class `f$1` {
        override fun toString(): String = name
    }
    return `f$1`()
}```

ah, I see. so an `object` is just a class instance that also has the property of being a singleton?

an `object` expression is not a singleton

<https://kotlinlang.org/docs/object-declarations.html#object-declarations-overview> singleton
<https://kotlinlang.org/docs/object-declarations.html#object-expressions> instance of anonymous class

| an `object` expression is not a singleton
but doesn't create an object expression a singleton of an anonymous class??
Your second link literally says "which is useful for implementing singletons"

it *can* be but it is not a singleton itself

```fun f() = object {}
f() != f()
f()::class == f()::class```

but surprisingly
```f()::class !== f()::class```
so the classes are equivalent, but not identical. And if the classes are not identical than you could `f()` still call a singleton :thinking_face:
here is the code: <https://pl.kotl.in/w35NYuhj9>

I think `::class` doesn't work that way. for example,
`String::class !== String::class`

looks like it's a property of the instance