Annihilator -- Structure with element that "annihilates" any other element of the set

[theamytran]

Annihilator -- Structure with element that "annihilates" any other element of the set

[non]

Hi @theamytran,

So it sounds like your proposal is something like this?

trait Annihilating[A] {
  def combine(x: A, y: A): A
  def annihilator: A
}

// and then elsewhere
class AnnihilatingForSet[A: Semigroup] extends Annihilating[Set[A]] {
  def combine(x: Set[A], y: Set[A]): Set[A] = x & y
  def annihilator: Set[A] = Set.empty[A]
}

val x = Set(1,2,3)
val y = Set.empty[Int]
AnnihilatingForSet[Int].combine(x, y) // returns Set()

Currently it would be possible to do something similar by defining a Semiring[Set[A]] using empty sets, unions, and intersections (which we currently have: https://github.com/typelevel/algebra/blob/master/core/src/main/scala/algebra/instances/set.scala#L26).

I guess I have a few questions for the group:

1. Does anyone know of any algorithms or structures that need only multiplication and zero?
2. How often do people encounter semigroups which can't be monoids but could be annihilators?
3. Would it make more sense to put this in the semigroup hierarchy or keep it alone?

My 2¢ is that it seems reasonable to add AnnihilatingSemigroup (and AnnihilatingMonoid) if we can think of more use cases that would benefit from having them. The set example is less compelling to me only because we already have Semiring[Set[A]].

[theamytran]

Here's another use case: interval intersection. https://gist.github.com/kenbot/1c37f10cd2ac8de2e988

[johnynek]

IntervalSets can also have Semirings as a note.

@theamytran do you have an algorithm in mind that you would write that uses a annihilation in the abstract?