Clases invocables

Parte de la sección Programación Orientada a Objetos del Journey de Dart de Coddy. Lección 84 de 110.

En Dart, puedes hacer que las instancias de una clase sean invocables como funciones implementando el método call(). Esto te permite usar un objeto con la sintaxis de llamada de función: usando paréntesis directamente en la instancia.

class Multiplier {
  final int factor;
  
  Multiplier(this.factor);
  
  int call(int value) {
    return value * factor;
  }
}

void main() {
  var double = Multiplier(2);
  var triple = Multiplier(3);
  
  print(double(5));   // 10 - llamando al objeto como una función
  print(triple(5));   // 15
}

Cuando escribes double(5), Dart invoca automáticamente el método call() con 5 como argumento. El objeto se comporta como una función, aunque mantiene su estado (el campo factor).

El método call() puede tener cualquier firma: varios parámetros, parámetros opcionales o incluso devolver tipos diferentes:

class Greeter {
  final String greeting;
  
  Greeter(this.greeting);
  
  String call(String name, {String punctuation = '!'}) {
    return '$greeting, $name$punctuation';
  }
}

void main() {
  var hello = Greeter('Hello');
  print(hello('Alice'));              // Hello, Alice!
  print(hello('Bob', punctuation: '.')); // Hello, Bob.
}

Las clases invocables son útiles cuando necesitas un comportamiento similar al de una función combinado con un estado o una configuración. Se usan habitualmente para crear operaciones, validadores o transformaciones reutilizables que necesitan recordar la configuración entre llamadas.

Desafío

Fácil

¡Construyamos un sistema de formato de texto usando clases invocables! Crearás objetos que se pueden invocar como funciones para transformar texto de diferentes maneras, mientras mantienen sus propias opciones de configuración.

Organizarás tu código en dos archivos:

formatters.dart: Crea dos clases invocables que transformen texto:
- Una clase Wrapper que envuelva el texto con un prefijo y un sufijo. Debe almacenar un String prefix y un String suffix y, cuando se la invoque con un parámetro String text, devolver el texto envuelto entre el prefijo y el sufijo.
- Una clase Repeater que repita el texto una cierta cantidad de veces. Debe almacenar un valor int times y, cuando se la invoque con un parámetro String text, devolver el texto repetido esa cantidad de veces, con un espacio entre cada repetición.
main.dart: Importa tus formateadores y demuestra cómo funcionan las clases invocables:
- Crea un Wrapper con el prefijo "[" y el sufijo "]"
- Crea otro Wrapper con el prefijo "***" y el sufijo "***"
- Crea un Repeater que repita 3 veces
- Invoca el primer envoltorio con "Hello" e imprime el resultado
- Invoca el segundo envoltorio con "Important" e imprime el resultado
- Invoca el repetidor con "Go" e imprime el resultado
- Finalmente, combínalos: invoca el primer envoltorio con el resultado de invocar el repetidor con "Dart" e imprime el resultado

¡Observa cómo cada objeto formateador recuerda su configuración y se puede invocar directamente con paréntesis, igual que una función!

Salida esperada:

[Hello]
***Important***
Go Go Go
[Dart Dart Dart]

Pruébalo tú mismo

import 'formatters.dart';

void main() {
  // TODO: Crea un Wrapper con prefijo "[" y sufijo "]"
  
  // TODO: Crea otro Wrapper con prefijo "***" y sufijo "***"
  
  // TODO: Crea un Repeater que repita 3 veces
  
  // TODO: Llama al primer wrapper con "Hello" e imprime el resultado
  
  // TODO: Llama al segundo wrapper con "Important" e imprime el resultado
  
  // TODO: Llama al repeater con "Go" e imprime el resultado
  
  // TODO: Combínalos: llama al primer wrapper con el resultado de
  // llamar al repeater con "Dart", e imprime el resultado
  
}