A modern programming language that makes developers happier.

kotlinlang

does kotlin have its own version of `Cloneable` as i cant find it in the docs nor in the search thing at <http://kotlinlang.org|kotlinlang.org>

Not sure what `Cloneable` is but every `data class` has a `copy` method

you can just use the one from `java.lang`

Clonable supposidly provides the `.clone()` method in alot of java classes

well java.lang.Cloneable is an empty interface anyway so just create your own I guess

You should try to avoid in Java too, it's a mess.

btw, if i have ```
var x = 1
fun a() {
    var y = x
    y = 6
    println(x)
    println(y)
}
a()
``` shouldnt x be modified such that y and x have the same value?

No, that's not how variables work in most programming languages.

You can think of variables as boxes, and `x = y` means "take the value that's in `y` and put it in `x` too". The boxes themselves, `x` and `y`, stay independent.

ok, so `y` would obtain the value of `x` and not the reference to `x` itself?

so to implement `clone()` i would do this? ```fun clone(): LinkedList&lt;T&gt; {
        val tmp = LinkedList&lt;T&gt;()
        tmp.head = head
        return tmp
    }```   if so would ```fun clone(): LinkedList&lt;T&gt; = LinkedList&lt;T&gt;().head = head``` also work?

Assignments aren't expressions in Kotlin, so the second won't work and wouldn't do what you wanted anyway.

he doesn't understand kotlin much, unfortunately - he's been spamming other networks for weeks with the same stuff

The first one appears to make a shallow clone, ie. if you mutate the clone the original will change too.

so i would need this? ```        val tmp = LinkedList&lt;T&gt;()
        forEach { tmp.append(it!!) }
        return tmp
```

Not sure why you've got the `!!`, but yeah.

can lists normally accept null values as valid elements?

eg MutableList&lt;String?&gt;().add(null)

They take a type parameter `T`, and users can make it nullable if they want, like in your example `String?`. The list code itself doesn't need to concern itself with nullability.