module ComposeEverything::FunctionalGoodies
  def compose(with)
    ->(x) { with[self[x]] }
  end
end

module ComposeEverything::FunctionalGoodies
  def compose(with)
    ->(x) { with[self[x]] }
  end

  def f_add(idx, output)
    union ->(x) {
      if x == idx then ouput end
    }
  end

  def intersection(with)
    ->(x) {
      a = self[x]
      if a == with[x]
        a
      end
    }
  end

  def union(with)
    ->(x) {
      a = self[x]
      if y.nil?
        a
      else
        with[x]
      end
    }
  end

  def f_delete(a)
    remove ->(x) {
      a
    }
  end

  def remove(removed)
    ->(x) {
      a = self[x]
      b = removed[x]
      if a != b
        a
      end
    }
  end
end

Add a couple of interesting functions
Add a couple of interesting functions

* `#f_add`, adds an output in the appropriate index
* `#intersection`, the (index, item) pairs the two sets share
* `#union`, Produces the two sets concatenated, or the union of the
setsin math terms
* `#f_delete`, deletes all items that are the same as a
* `#remove`, removes all items shared by the two sets. Equivalent to
(A.union B).remove(A.intersection B)
