$services->set(IndexBuilder::class)
  ->arg(
    '$indexName',
    expr("env('index_prefix') ~ '_' ~ parameter('main_index_name')"),
  );

use Symfony\Component\Security\Http\Attribute\IsGranted;

final class ViewPostController
{
  #[IsGranted('"ROLE_ADMIN" in roles or is_granted("VIEW", subject)', subject: 'post')]
  public function __invoke(Post $post): Response
  {
    return new Response('ok');
  }
}

$el = new ExpressionLanguage();

$isAGreatCustomer = $el->evaluate(
  '((100 * order.discount) / order.total) < 5',
  ['order' => $customer->getLastOrder()]),
);

$el = new ExpressionLanguage();

$ruleToBeEligible = <<<EOT
  placed_an_order_in(customer, 2025)
  &&
  is_registered_to_the_loyalty_program(customer)
  &&
  billing_address_located_in(customer, "France")
EOT;

$eligible = $el->evaluate(
  $ruleToBeEligible,
  ['customer' => $customer],
);

$el = new ExpressionLanguage();

$eligible = $el->evaluate(
  $rules->findEligibleForDiscount(),
  ['customer' => $customer],
);

$el = new ExpressionLanguage();

$eligible = $el->evaluate(
  $rules->findEligibleForDiscount(),
  ['customer' => $customer],
);

new ExpressionFunction(

  name: 'is_registred_to_the_loyalty_program',
  
  compiler: static function (string $s): string {
    // ...
  },

  evaluator: static function (array $args, Customer $c): bool {
    return $args['loyaltyProgram']->registred->contains($c);
  },

)

final class LoyaltyProgramFunctionProvider implements ExpressionFunctionProviderInterface
{
    public function getFunctions(): array
    {
        return [
            new ExpressionFunction('is_registred_to_the_loyalty_program', ...),
            new ExpressionFunction(...),
            // ...
        ];
    }
}

use Symfony\Component\ExpressionLanguage\ExpressionLanguage as BaseEL;

final class ECommerceExpressionLanguage extends BaseEL
{
    public function __construct(
      CacheItemPoolInterface $cache = null,
      array $providers = [],
    ) {
        array_unshift($providers, new LoyaltyProgramFunctionProvider());
        array_unshift($providers, new CouponsFunctionProvider());

        parent::__construct($cache, $providers);
    }
}

final class EligibilityChecker
{
    public function __construct(
        private ECommerceExpressionLanguage $el,
    ) {}

    public function isEligible(string $condition, Customer $customer): bool
    {
        return $this->el->evaluate($condition, [
            'customer' => $customer,
        ]);
    }
}

final class EligibilityChecker
{
    public function __construct(
        private ECommerceExpressionLanguage $el,
        private NormalizerInterface $normalizer,
    ) {}

    public function isEligible(string $condition, Customer $customer): bool
    {
        return $this->el->evaluate($condition, [
            'customer' => $this->normalizer->normalize($customer),
        ]);
    }
}

final class UpdateIsEligibleForDiscountRuleAction extends AbstractController
{
    public function __invoke(Request $request, RuleRepository $rules): Response
    {
        $expression = $rules->getEligibleForDiscount();

        $form = $this->createForm(ExpressionType::class, $expression);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $rules->saveEligibleForDiscount($form->getData());

            return $this->redirectToRoute('rules');
        }

        return $this->render('update_is_eligible_for_discount_rule.html.twig', [
            'form' => $form,
        ]);
    }
}

class ExpressionLanguage
{
	/**
     * Validates the syntax of an expression.
     *
     * @param array $names The list of acceptable variable names in the expression
     * @param int-mask-of<Parser::IGNORE_*> $flags
     *
     * @throws SyntaxError When the passed expression is invalid
     */
    public function lint(Expression|string $expression, array $names, int $flags = 0): void
}

readonly final class ApplyDiscountCommandHandler
{
  public function __construct(
    private ECommerceExpressionLanguage $el,
    private RuleRepository $rules,
    private LoyaltyProgram $loyaltyProgram,
  ) {
  }

  public function __invoke(ApplyDiscountCommand $command): void
  {
    $eligible = $el->evaluate($rules->findEligibleForDiscount(), [
      'customer' => $command->customer,
      'loyaltyProgram' => $this->loyaltyProgram,
    ]);
    
    if (!$eligible) {
      return;
    }
    
    // ...
  }
}