Functional Replacement Pattern (En)

ClientFlow.kt

// Control interface
interface ClientFlow {
    fun executeFlow()
}

ClientFlowTransform.kt

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

    override fun executeFlow() {
        executionFlow.contextFlow { data: Any ->
            // Transforms, creations, instances, updates, etc.
            emitterFlow.emitFlow(anotherObject)
        }
    }
}

ClientFlowTransformProcess.kt

interface ClientFlow {
    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

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

// Isolation interface
interface ExecutionFlow {
    fun contextFlow(scope: ContextScope)
}

EmitterFlow.kt

// Receiving interface
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
)

// Manual test structure
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) // Output: True
}

LegacyExecutionFlow.kt

class LegacyExecutionFlow : ExecutionFlow {

    // Isolated, non-interpretable context.
    private val legacyContext = LegacyContext()

    // Transformed and emitted context.
    override fun contextFlow(scope: ContextScope) {
        /**
         * Creations, invocations, and definitions of 
         * data which you would like to pass to the 
         * new code execution structure.
         */
        val contextData = // Código final mapeado.    
        scope.onContext(newContext)
    }
}

NewFeatureContext.kt

class NewFeatureContext : EmitterFlow {
  
    // Reception and final processing method.
    override fun emitFlow(data: Any) {
        /**
         * Creation of the new algorithms that will be 
         * maintained and structured in a testable manner.
         */
    }
}