Пользовательский синтаксис Perl для передачи аргументов функции

Я рекомендую попробовать Parse::Keyword. Parse::Keyword отлично подходит для разбора пользовательского синтаксиса, так как позволяет вызывать различные части парсера Perl, такие как parse_listexpr, parse_block, parse_fullstmt и т. д. (см. perlapi).

У него есть недостаток в том, что если вы используете их для анализа выражений, которые закрываются над переменными, они обрабатываются плохо, но это можно обойти с помощью PadWalker.

Parse::Keyword (включая обман PadWalker) — это то, что использует Kavorka; и это делает довольно сложные вещи! Ранние версии p5-mop-redux тоже использовали его.

Во всяком случае, вот демонстрация того, как ваша странная функция может быть проанализирована...

use v5.14;
use strict;
use warnings;

# This is the package where we define the functions...
BEGIN {
  package Math::Weird;

  # Set up parsing for the functions
  use Parse::Keyword {
    add      => \&_parser,
    subtract => \&_parser,
    multiply => \&_parser,
    divide   => \&_parser,
  };

  # This package is an exporter of course
  use parent 'Exporter::Tiny';
  our @EXPORT = qw( add subtract multiply divide );

  # We'll need these things from PadWalker
  use PadWalker qw( closed_over set_closed_over peek_my );

  sub add {
    my @numbers = _grab_args(@_);
    my $sum = 0;
    $sum += $_ for @numbers;
    return $sum;
  }

  sub subtract {
    my @numbers = _grab_args(@_);
    my $diff = shift @numbers;
    $diff -= $_ for @numbers;
    return $diff;
  }

  sub multiply {
    my @numbers = _grab_args(@_);
    my $product = 1;
    $product *= $_ for @numbers;
    return $product;
  }

  sub divide {
    my @numbers = _grab_args(@_);
    my $quotient = shift @numbers;
    $quotient /= $_ for @numbers;
    return $quotient;
  }

  sub _parser {
    lex_read_space;

    my @args;
    while (lex_peek eq '(')
    {
      # read "("
      lex_read(1);
      lex_read_space;

      # read a term within the parentheses
      push @args, parse_termexpr;
      lex_read_space;

      # read ")"
      lex_peek eq ')' or die;
      lex_read(1);
      lex_read_space;
    }

    return sub { @args };
  }

  # In an ideal world _grab_args would be implemented like
  # this:
  #
  #    sub _grab_args { map scalar(&$_), @_ }
  #
  # But because of issues with Parse::Keyword, we need
  # something slightly more complex...
  #
  sub _grab_args {
    my $caller_vars = peek_my(2);
    map {
      my $code = $_;
      my $closed_over = closed_over($code);
      $closed_over->{$_} = $caller_vars->{$_} for keys %$closed_over;
      set_closed_over($code, $closed_over);
      scalar $code->();
    } @_;
  }

  # We've defined a package inline. Mark it as loaded, so
  # that we can `use` it below.
  $INC{'Math/Weird.pm'}  = __FILE__;
};

use Math::Weird qw( add subtract multiply );

say add(2)(3);          # says 5
say subtract(40)(20);   # says 20

say multiply( add(2)(3) )( subtract(40)(20) );   # says 100

Если вы можете жить с добавлением символа и стрелки, вы можете карри subtract как в

my $subtract = sub {
  my($x) = @_;

  sub { my($y) = @_; $x - $y };
};

Назовите это как в

my $result = $subtract->(40)(20);

Если стрела приемлема, но не сигил, переделайте subtract как

sub subtract {
  my($x) = @_;

  sub { my($y) = @_; $x - $y };
};

Вызов в этом случае выглядит как

my $result = subtract(40)->(20);

Пожалуйста, не добавляйте неработающие расширения синтаксиса в свою программу, чтобы решить решенную проблему. Вам нужны замыкания и метод, иногда называемый каррингом.

Каррирование — это работа по преобразованию функции, которая принимает несколько аргументов, в функцию, которая вызывается несколько раз с одним аргументом каждая. Например, рассмотрим

sub subtract {
  my ($x, $y) = @_;
  return $x - $y;
}

Теперь мы можем создать подпрограмму, которая уже предоставляет первый аргумент:

sub subtract1 { subtract(40, @_) }

Вызов subtract1(20) теперь оценивается как 20.

Вместо этого мы можем использовать анонимные подпрограммы, что делает это более гибким:

my $subtract = sub { subtract(40, @_) };
$subtract->(20);

Нам не нужна эта переменная:

sub { subtract(40, @_) }->(20); # equivalent to subtract(40, 20)

Мы можем написать subtract так, чтобы сделать это напрямую:

sub subtract_curried {
  my $x = shift;
  # don't return the result, but a subroutine that calculates the result
  return sub {
    my $y = shift;
    return $x - $y;
  };
}

Теперь: subtract_curried(40)->(20) — обратите внимание на стрелку между ними, так как мы имеем дело с ссылкой на код (другое название анонимной подпрограммы или замыкания).

Этот стиль написания функций гораздо более распространен в функциональных языках, таких как Haskell или OCaml, где синтаксис для этого красивее. Это позволяет очень гибко комбинировать функции. Если вас интересует такое программирование на Perl, вы можете прочитать Perl высшего порядка.