Is there a proposal for a `+-` or `.plusOrMinus` o...

# language-proposals

[xxfast]

Is there a proposal for a +- or .plusOrMinus operator that does

val fruits = listOf("🍎", "🍊", "🍌")
print(fruits ± "🥝") // "🍎", "🍊", "🍌", "🥝"
print(fruits ± "🍊") // "🍎", "🍌"

which works like

operator fun <T> Collection<T>.plusOrMinus(item: T): Collection<T> = 
  if (item in this) this + item 
  else this - item

[ephemient]

imo this should be xor if we ever got bitwise operators

[xxfast]

Here's a simple usecase i have in my compose app where you can collapse sections within a list

@Composable
fun ListScreen(items: List<Item>) {
  var collapsed: Set<Category> by rememberSaveable { mutableStateOf(emptySet()) }

  val groups = items.groupBy { item.category }

  LazyColumn {
    Category.entries.forEach { category ->
      item(span = FullLine) {
        CollapsableHeader(
          isCollapsed = category in collapsed,
          onClick = { collapsed = (collapsed ± category).toSet() }
        ) {
          Text(category.text)
        }
      }
      
      if(category !in groups) items(groups[category].entries) { item ->
        ItemView(item)
      }
    }
  }
}

[ephemient]

also it might be more similar to other collections extensions with a signature like

infix fun <T> Iterable<T>.xor(item: T): List<T> = toMutableList().apply { remove(item) || add(item) }

[xxfast]

does xor have a operator?

[ephemient]

there's a youtrack request for bitwise operators but for now there's only infix funs

[ephemient]

https://youtrack.jetbrains.com/issue/KT-1440

[Alejandro Serrano.Mena]

note that infix functions can take you a lot way