     public init<Argument, ReturnType>(argument: Argument.Type, signature: String, _ block: @escaping (Argument) -> ReturnType) {
         self.methodSignature = signature
         modelTypeCheckingBlock = { _ in true }
+        supplementaryKind = nil
         reaction = { argument, _, _ in
             guard let argument = argument as? Argument else {
                 return 0

    public init<View, ModelType, ReturnType>(viewType: View.Type,
                                            modelType: ModelType.Type,
                                            signature: String,
                                            _ block: @escaping (View, ModelType, IndexPath) -> ReturnType) {
        self.methodSignature = signature
        modelTypeCheckingBlock = nil
        reaction = { view, model, indexPath in
            guard let model = model as? ModelType,
                let indexPath = indexPath as? IndexPath,

            (view?.isKind(of: mapping.viewClass) ?? true) &&
            mapping.condition.isCompatible(with: indexPath, model: unwrappedModel) &&
                mapping.reactions.contains { $0.methodSignature == signature }
        })?.reactions.first(where: { $0.methodSignature == signature && $0.supplementaryKind == supplementaryKind })
    }
    
    /// Performs reaction of `type`, `signature`, with `view`, `model` in `location`.
    static func performReaction(from mappings: [ViewModelMappingProtocol], signature: String, view: Any?, model: Any, location: IndexPath, supplementaryKind: String? = nil) -> Any {
        guard let reaction = reaction(from: mappings, signature: signature, forModel: model, at: location, view: view as? UIView, supplementaryKind: supplementaryKind) else {
            return 0
        }
        return reaction.performWithArguments((view ?? 0, model, location))
