 public protocol Selectable: class
 {
   /**
-    Select registers its notification channel by calling an implementation's selectReceive() method.
-    This channel is a subtype of SingletonChannel and thus only one recipient will be able to respond.
+    Select registers its notification semaphore by calling an implementation's selectNotify() method.
 
     -> whatever code sends a notification back must run asynchronously.
 
-    Associated data can be sent back along with the notification by copying it to the SelectChan.stash
-    property. This (and sending the notification) can be done safely inside a closure that is invoked
-    through the channel's SelectChan.channelMutex() method. This ensures that it runs synchronously
-    with any other closures attempting to do the same, ensuring that only the first succeeds.
+    Associated data can be sent back along with the semaphore by copying an 'Unmanaged' reference to
+    a Selection via the semaphore's Context property (dispatch_set_context()).
 
-    :param: channel the channel to use for a return notification.
-    :param: message an identifier to be sent as the return notification.
+    ***
+    let selection = Selection(selectionID: selectionID, selectionData: element)
+    let context = UnsafeMutablePointer<Void>(Unmanaged.passRetained(selection).toOpaque())
+    dispatch_set_context(s, context)
+    dispatch_semaphore_signal(s)
+    ***
+
+    Only one attempty to obtain the semaphore can succeed, thus one and only one Selectable can
+    return data for each given invocation of Select().
+
+    selectNotify launches a block of code for background execution, which is likely to block
+    while waiting for data. selectNotify must return a closure capable of unblocking a thread
+    waiting in the background. This paragraph is like word soup.
+
+    :param: channel a channel from which to obtain a semaphore to use for a return notification.
+    :param: message an identifier to be used to identify the return notification.
   
     :return: a closure to be run once, which can unblock a stopped thread if needed.
   */

  func selectNotify(semaphore: SingletonChan<dispatch_semaphore_t>, selectionID: Selectable) -> Signal

  /**
    If it makes no sense to invoke the selectReceive() method at this time, return false.
    If every Selectable in the list returns false, Select will assume that it should stop.
  */

  var selectable: Bool { get }
}

/**
  A particular kind of Anything.
*/

//public protocol SelectionType: class
//{
////  var selectable: Selectable { get }
////  func getMessageID() -> Selectable
//}

/**
  A channel that is Selectable should know how to extract data from one of these.
  After all, it should have created the object in its selectReceive() method.
*/

protocol SelectableChannelType: ChannelType
{

//  func insert(item: Selection) -> Bool
}


/**
  You can put anything in a Selection.
  It has a convenient, non-generic type,
  coupled to a decidedly generic accessor method.
*/

public class Selection
