How to do this in Kotlin?

I am trying to create a simple data class for a country.

data class Country(val name: String, val capital: String)

This works fine. Now I want to add neighbors.

data class Country(val name: String, val capital: String, val neighbors: List<Country>)

This causes problems. Canada and USA are neighbors. How can I cleanly instantiate each of these country objects? I would prefer to not make the neighbors element mutable. Is it possible to do this?
(I tried to create countries without neighbors at first and then create ones with neighbors using the copy constructor. But then equals method has issues.)
It seems like a simple issue but I am not sure how to solve.

I think you should rather represent the neighbors by their id and then create a function to perform the query. Here is my solution

data class Country(
    val id : Int,
    val name: String,
    val capital: String,
    val neighbors: List<Int> = emptyList(),
){
    // Function to retrieve neighbors
    fun  getNeighbors(countries : List<Country>) : List<Country>{
        return  countries.filter { it.id in neighbors }
    }
}

val Togo = Country(id = 1, name = "TOGO", capital = "Lome", neighbors = listOf(2, 3, 4))
val Benin = Country(id = 2, name = "Benin", capital = "Porto Novo", neighbors = listOf(1))
val Ghana = Country(id = 3, name = "Ghana", capital = "Accra", neighbors = listOf(1, 2))
val Burkina = Country(id = 4, name = "Burkina Faso", capital = "Ouagadougou", neighbors = listOf(1, 2, 3))

val allCountries = listOf(Togo, Benin, Ghana, Burkina)

//Here you have the list of neighbors
val beninNeighbors = Benin.getNeighbors(allCountries)

Not sure what exactly is your case.

But first, in my mind is that this data representation is problematic.
Imagine for example toString method. USA will call toString of neighbors it will call toString on Canada and then back to the USA and this never ends ...

Another approach would be to hold the logic of neighbors in separate class.
It can be encapsulated and it will not be possible to configure an incorrect state, where the USA is a neighbor of Canada but not vice versa.

It can look like this:

data class Country(val name: String, val capital: String)

class Neighbours(vararg neighbour: Pair<Country, Country>) {
    private val neighbours: MutableMap<Country, MutableSet<Country>> = mutableMapOf()

    init {
        neighbour.forEach {
            neighbours.getOrPut(it.first) { mutableSetOf() }.add(it.second)
            neighbours.getOrPut(it.second) { mutableSetOf() }.add(it.first)
        }
    }

    fun getNeighbours(c: Country): Set<Country> = neighbours[c] ?: emptySet()
}

And usage sample

class Model() {
    val canada = Country("Canada", "Ottawa")
    val usa = Country("USA", "Washington")
    val mexico = Country("Mexico", "Mexico City")

    val neighbours = Neighbours(Pair(canada, usa), Pair(usa, mexico))

    fun usage() {
        println(usa.getNeighbours())
    }

    fun Country.getNeighbours() = neighbours.getNeighbours(this)
}

fun main() = Model().usage()

Edouardsepopo Zinnoussou's answer requires the caller to pass around the allCountries collection. If you don't like that then here is a solution that avoids that:

data class Country(val name: String, val capital: String) {
    val neighbors: Set<Country> by lazy {
        CountryFactory.neighborsByCountry[this]!!
    }
}

... using lazy to handle the late binding of the data. Note that the Country object now would not expose the neighbors in the toString/equality/etc but the strategy here is to use a Factory to make the countries:

object CountryFactory {
    val togo = Country(name = "TOGO", capital = "Lome")
    val benin = Country(name = "Benin", capital = "Porto Novo")
    val ghana = Country(name = "Ghana", capital = "Accra")
    val burkina = Country(name = "Burkina Faso", capital = "Ouagadougou")
    val neighborsByCountry: Map<Country, Set<Country>> = mapOf(
        togo to setOf(benin, ghana, burkina),
        benin to setOf(togo),
        ghana to setOf(togo, benin),
        burkina to setOf(togo, benin, ghana),
    )
}

@Test
fun togoHasCorrectNeighbors() {
    CountryFactory.togo.neighbors.shouldContainAll(
        CountryFactory.benin, CountryFactory.ghana, CountryFactory.burkina,
    )
}