Functional Replacement Pattern

ClientFlow.kt

// Interface de controle
interface ClientFlow {
    fun executeFlow()
}

ClientFlowTransform.kt

class ClientFlowTransform(
    private val executionFlow: ExecutionFlow,
    private val emitterFlow: EmitterFlow
) : ClientFlow {

    override fun executeFlow() {
	executionFlow.contextFlow { data: Any ->
	    // Edições, criações, atualizações, etc.
	    emitterFlow.emitFlow(anotherObject)
	}
    }
}

ClientFlowTransformProcess.kt

interface ClientFlow {
    override fun createState()
}

class ClientFlowTransform(
    private val executionFlow: ExecutionFlow,
    private val emitterFlow: EmitterFlow
) : ClientFlow {

    override fun createState() {
        executionFlow.onScope { newContext: NewContext ->
	    emitterFlow.emitFlow(newContext.param.uppercase())
	}
    }
}

ContextScopeEmitFlow.kt

// Interface funcional
fun interface ContextScope {
    fun onContext(contextData: Any)
}

// Interface de isolamento
interface ExecutionFlow {
    fun contextFlow(scope: ContextScope)
}

EmitterFlow.kt

// Interface de recepção
interface EmitterFlow {
    fun emitFlow(data: Any)
}

EmitterFlowReceiverFake.kt

interface EmitterFlow {
    fun emitFlow(data: String)
}

class EmitterFlowReceiverFake : EmitterFlow {
    
    private var lastMessage = String()

    override fun emitFlow(data: String) {
	lastMessage = data
    }

    fun getLastMessage(): String = lastMessage

}

ExecutionFlowFake.kt

interface ExecutionFlow {
    fun contextFlow(scope: ContextScope)
}

class ExecutionFlowFake(
    private val newContext: NewContext
) : ExecutionFlow {

    override fun contextFlow(scope: ContextScope) {
	scope.onContext(newContext.param)
    }
}

FunctionalReplacementTest.kt

data class NewContext(
    val param: String
)

// Estrutura de testes manual
fun main() {
    val expected = "ANY"
    val newContext = NewContext("any")
    val fakeEnvironment = ExecutionFlowFake(newContext)
    val emitterFlowReceiverFake = EmitterFlowReceiverFake()
    val processState: ClientFlow = ClientFlowTransform(fakeEnvironment, emitterFlowReceiverFake)

    processState.executeFlow()

    val result = terminateEnvironmentFake.getLastMessage()

    println(expected == result) // Saída: True
}

LegacyExecutionFlow.kt

class LegacyExecutionFlow : ExecutionFlow {

    // Contexto não interpretável isolado
    private val legacyContext = LegacyContext()

    // Contexto transformado e emitido
    override fun contextFlow(scope: ContextScope) {
        /**
         * Criações, invocações e definições dos dados que
         * gostaria de passar para a nova estrutura de execução 
         * do código.
         */
        val contextData = // Código final mapeado.    
        scope.onContext(newContext)
    }
}

NewFeatureContext.kt

class NewFeatureContext : EmitterFlow {
  
    // Método de recepção e processamento final.
    override fun emitFlow(data: Any) {
	/**
	 * Criação dos novos algoritmos que serão
	 * mantidos e estruturados de forma testável.
	 */
    }
}