         return filter({ reaction in
             guard let unwrappedModel = RuntimeHelper.recursivelyUnwrapAnyValue(model) else { return false}
             return reaction.type == type &&
-                String(reaction.modelClass) == String(unwrappedModel.dynamicType) &&
+                reaction.modelTypeCheckingBlock(unwrappedModel) &&
                 reaction.methodSignature == signature
         }).first
     }
     
-    func performReaction(ofType type: EventType, signature: String, view: Any, model: Any, location: Any) -> Any {
+    func performReaction(ofType type: EventType, signature: String, view: Any?, model: Any, location: Any) -> Any {
         guard let reaction = reactionOfType(type, signature: signature, forModel: model) else {
             return 0
         }


public final class EventReaction {
    public var type: EventType = .cell
    public let modelClass: Any.Type
    public var reaction : ((Any,Any,Any) -> Any)?
    public let methodSignature: String
    
    public init(signature: String, modelClass: Any.Type) {
        self.methodSignature = signature
        self.modelClass = modelClass
    }
    
    public func makeCellReaction<T,U where T: ModelTransfer>(block: (T?, T.ModelType, IndexPath) -> U) {
        type = .cell
        reaction = { cell, model, indexPath in
            guard let model = model as? T.ModelType,
                let indexPath = indexPath as? IndexPath else {

    }
    
    public func makeSupplementaryReaction<T,U where T: ModelTransfer>(forKind kind: String, block: (T, T.ModelType, Int) -> U) {
        modelTypeCheckingBlock = { return $0 is T.ModelType }
        type = .supplementary(kind: kind)
        reaction = { supplementary, model, sectionIndex in
            guard let model = model as? T.ModelType,
                let index = sectionIndex as? Int,
                let supplementary = supplementary as? T else
            {
                    return ""
            }
            return block(supplementary, model, index)
        }
    }
    
