Strategy Pattern with Anonymous Function Closure - php

Question

I want to implement the Stategy Pattern using Closures in php. The main advantage of using closure is to reduce the amount of boilerplate and code needed by creating additional classes. Usually the pattern looks like this:
interface StateDiscountCalculatorInterface
{
public function calculateDiscount($amount);
}
class NewYorkStateStrategy implement StateDiscountCalculatorInterface
{
public function calculateDiscount($amount)
{
// .... about 20 lines of code
}
}
class CaliforniaStateStrategy implement StateTaxCalculatorInterface
{
public function calculateDiscount($amount)
{
// .... about 20 lines of code that's different from New York State Strategy
}
}
class stateTaxContext
{
private $stategy;
public function setStrategy(StateDiscountCalculatorInterface $strategy)
{
$this->strategy = $strategy;
}
public function getDiscount(array $amount)
{
return $this->strategy->calculateDiscount($amount);
}
}
The version below is with a closure implementing a php functional interface. Is this the right way to do this?
interface StateDiscountCalculatorInterface
{
public function calculateDiscount($amount);
}
class stateTaxContext
{
private $newYorkStateStrategy;
private $californiaStateStrategy;
private $state;
public function __construct()
{
$this->newYorkStateStrategy = function () implements StateDiscountCalculatorInterface {
...NewYorkStateStrategy class is replaced with code here
};
$this->californiaStateStrategy = function () implements StateDiscountCalculatorInterface {
...CaliforniaStateStrategy class is replaced with code here
};
}
public function getDiscount(array $amount)
{
if($this->state==='california')
{
$this->californiaStateStrategy->calculateDiscount($amount);
}
}
}

Answer 1

I am not a design patterns expert, but to my mind one of the best approaches to implement a strategy pattern would be the following - you may keep the interface & strategy classes as they are, but implement context like this:
class StateTaxContext
{
private $state;
public function setState(StateDiscountCalculatorInterface $state)
{
$this->state = $state;
}
public function getDiscount(array $amount)
{
return $this->state->->calculateDiscount($amount);
}
}
And then you may use this pattern everywhere in your code like this:
$context = new StateTaxContext();
// Calculate NY discount?
$context->setState(new NewYorkStateStrategy());
$data = $context->getDiscount($amount);
// Calculate California discount?
$context->setState(new CaliforniaStateStrategy());
$data = $context->getDiscount($amount);