Command Design Pattern in R

1. Definition

The Command Design Pattern encapsulates a request as an object, allowing for parameterization of clients with different requests, queueing of requests, and logging the operations. It also supports undoable operations.

2. Problem Statement

Imagine you are designing a software for a home automation system where you can control various devices such as lights, fans, and music systems. As you add more devices, you don't want to change existing code or clutter your system with numerous if-else conditions to handle every device's action.

3. Solution

Encapsulate each action as a command object. This way, new commands can be added without changing the existing code. Command objects decouple the object that invokes the action from the object that knows how to perform the action.

4. Real-World Use Cases

1. Remote controls for electronic devices.

2. Macro recording in software applications.

3. Task scheduling systems.

5. Implementation Steps

1. Define a command interface with an execute method.

2. Create one or more concrete classes that implement this command interface, where each class represents a different command.

3. Have a command invoker class. It can invoke the command, and if required, keep a history for undo functionality.

6. Implementation in R Programming

# Step 1: Command Interface
Command <- setRefClass("Command", methods = list(execute = function() {}))
# Step 2: Concrete Command Classes
TurnOnLight <- setRefClass("TurnOnLight", contains = "Command",
  fields = list(light = "ANY"),
  methods = list(
    execute = function() {
      light$turn_on()
    }
  )
)
TurnOffLight <- setRefClass("TurnOffLight", contains = "Command",
  fields = list(light = "ANY"),
  methods = list(
    execute = function() {
      light$turn_off()
    }
  )
)
# Receiver Class
Light <- setRefClass("Light", methods = list(
  turn_on = function() { cat("Light is ON\n") },
  turn_off = function() { cat("Light is OFF\n") }
))
# Command Invoker Class
RemoteControl <- setRefClass("RemoteControl",
  fields = list(command = "Command"),
  methods = list(
    set_command = function(cmd) {
      .self$command <- cmd
    },
    press_button = function() {
      .self$command$execute()
    }
  )
)
# Client Code
light <- Light$new()
turn_on <- TurnOnLight$new(light = light)
turn_off <- TurnOffLight$new(light = light)
remote <- RemoteControl$new()
remote$set_command(turn_on)
remote$press_button()
remote$set_command(turn_off)
remote$press_button()

Output:

Light is ON
Light is OFF

Explanation:

1. We define a Command interface that has a method named execute.

2. We then create concrete command classes for different actions: TurnOnLight and TurnOffLight.

3. The Light class (Receiver) knows how to perform the actions.

4. The RemoteControl class (Invoker) triggers the command.

5. In the client code, we instantiate the light, the commands, and the remote. We then set a command on the remote and press its button to invoke the command.

7. When to use?

Use the Command Design Pattern when:

1. You want to decouple the object that invokes an operation from the one that knows how to perform it.

2. You want to parameterize objects with operations.

3. Operations need to be executed at different times or in different sequences.

4. The system needs to support undo or logging changes.

Using command objects makes it easier to construct general components that need to delegate, sequence or execute method calls at a time of their choosing without the need to know the class of the method or the method parameters.