Monty Hall Problem （蒙提霍爾問題）是個奇妙而有趣的數學遊戲問題。維基百科上提供的問題本文為：

假設你正在參加一個遊戲節目，你被要求在三扇門中選擇一扇：其中一扇後面有一輛車；其餘兩扇後面則是山羊。你選擇了一道門，假設是一號門，然後知道門後面有什麼的主持人，開啟了另一扇後面有山羊的門，假設是三號門。他然後問你：「你想選擇二號門嗎？」轉換你的選擇對你來說是一種優勢嗎？

此問題的解答是「會」，也就是換答案後會比較容易得到汽車的意思。

但，這答案是以列舉出幾種狀況的機率來比較而得的。以機率而論，如果我能玩這遊戲 1000 次，那麼每一局都依主持人提供的資訊來更換答案後，我能在這 1000 局內獲勝的總次數較多。期望值約為 1000 2/3，也就是約為 666 次。而如果我每一局都不換答案，那我在這 1000 局內的獲勝期望值則為 1000 1/3，也就是約為 333 次。

既然如此，那就必須寫個程式來模擬看看了。以下是 play-monty-hall.pl ，以 perlclass 提供的新語法寫成的一個模擬程式，可模擬兩種策略玩家在玩了多局之後的勝率。雖然沒有註解，但應該還算是能夠望文生義的程度。

          #!/usr/bin/env perl
use v5.38;
use feature 'class';
no warnings 'experimental::class';

class Game {
    field $doors :param;
    field $winningDoor = 1 + int rand($doors);

    method doors { $doors }
    method winningDoor { $winningDoor }

    method loosingDoors {
        grep { $_ != $winningDoor } (1..$doors);
    }
};

class FirstChoicePlayer {
    field $doors :param;
    field $firstChoice = 1 + int rand($doors);
    field @loosingDoors;

    method doors { $doors }
    method addLoosingDoors ($n) { push @loosingDoors, $n }
    method loosingDoors () { @loosingDoors }
    method firstChoice () { $firstChoice }
    method finalChoice () { $firstChoice }
};

class ChangeChoicePlayer :isa(FirstChoicePlayer) {
    method finalChoice () {
        my %isLoosing = map { $_ => 1 } $self->loosingDoors();
        my @choices = grep { $_ != $self->firstChoice() } grep { ! $isLoosing{$_} } 1..$self->doors();

        die "Illegal state" if @choices != 1;
        return $choices[0];
    }
};

class GameMaster {
    field $doors :param;
    method playWith ($player) {
        die "No player ?" unless defined $player;

        my $game = Game->new( doors => $doors );

        my %untold = map { $_ => 1 } ($game->winningDoor, $player->firstChoice);
        while ((keys %untold) == 1) {
            my $door = 1 + int rand($doors);
            $untold{$door} = 1;
        }
        my @revealLoosingDoors = grep { ! $untold{$_} } (1..$doors);

        for my $door (@revealLoosingDoors) {
            $player->addLoosingDoors($door)
        }

        my $finalChoice = $player->finalChoice();

        return $finalChoice == $game->winningDoor;
    }
};

sub playOneRound($playerClass) {
    my $doors = 3;
    my $gm = GameMaster->new( doors => $doors );
    my $player = $playerClass->new( doors => $doors );
    return $gm->playWith( $player );
}

sub play ($rounds, $playerClass) {
    my $wins = 0;
    for (1 .. $rounds) {
        my $win = playOneRound($playerClass);
        $wins++ if $win;
    }
    return $wins;
}

sub sim ($rounds) {
    for my $playerClass ("FirstChoicePlayer", "ChangeChoicePlayer") {
        my $wins = play($rounds, $playerClass);
        my $pWin = $wins / $rounds;
        say "$playerClass wins $wins / $rounds. p(win) = $pWin";
    }
}

sim(shift // 1000);

        

可以提供一個參數，表示要模擬幾局。預設為 1000 局。執行起來如下：

          # play-monty-hall.pl
FirstChoicePlayer wins 323 / 1000. p(win) = 0.323
ChangeChoicePlayer wins 665 / 1000. p(win) = 0.665

# play-monty-hall.pl 1000000
FirstChoicePlayer wins 333606 / 1000000. p(win) = 0.333606
ChangeChoicePlayer wins 666348 / 1000000. p(win) = 0.666348
        

這程式內主要幾個互相作用的 class:

• FirstChoicePlayer: 以不變為其策略的玩家
• ChangeChoicePlayer: 以改變為其策略的玩家
• GameMaster: 與玩家互動的遊戲主持人。
• Game: 維護單一一局的遊戲初始資訊。基本上只有記住哪號門是贏門 ($winnigDoor)，並提供列舉出所有輸門的方法 loosingDoors

Game 物件在建構、初始完畢後計基本上是個常數了，沒有什麼特別的地方。 FirstChoicePlayer 也差不多，只是會有個 @loosingDoors 內部狀態來記著那些由 GameMaster 提供的輸門號碼。

而此處我讓 ChangeChoicePlayer 為 FirstChoicePlayer 的延伸，依照 $self->firstChoice 與 $self->loosingDoors 的內容來推算出 finalChoice。這邊我原本以為透過繼承機制，FirstChoicePlayer 的兩個 field 變數都可以直接在 ChangeChoicePlayer 內來使用。但結果是不行，必須在透過 FirstChoicePlayer 內定義的 getter method 才行。這表示由 field 所定義出來的便是是私有於該類別而已。

在所有類別中有一項共同參數 $doors，也就是這遊戲的門的數量。Game 類別是依 $doors 來隨機生成出贏門的號碼。兩個玩家類別內則是以數字去隨機產生 firstChoice。GameMaster 類別則是以此資訊來建構先的 Game 物件，還有推算出能告訴玩家哪些門是輸門。這邊我用了 :param 這個添在 field 變數上的屬性 (field $doors :param;)，來代表說這 field 的值必須被提供給類別的建構函式 new。這用法尚算直覺。而其他依賴 $doors 的值所計算出來的各 field 都似乎是正確地在物件建構時期被計算完畢了。無須另外調整。

目前幾個有需要用到的 getter method 都是我自己手動補上的，讓程式碼看來量很多。但依 perlclass 文件中 TODO 一節 內的說明，看來以後能寫個 :reader 來讓 perl 自動生成出 getter method。就能省下不少打字的力氣。

雖然 perlclass 語法跟類別機能十分基本，比不上其他以物件導向為核心設計的語言。但以這個小程式的用途用起來沒意外，很夠用。等以後改版之後再來看看有沒有什麼更有意思的地方。

這一次的 YAPC Japan 是辦在廣島國際會議中心，位於和平紀念公園內，離原爆圓頂館很近。雖然離市中心區有一小段距離，但走起來並不算遠。

比起去年的 YAPC::Kyoto，這次的活動規模似乎擴大了。贊助商數竟然超過 50 家，而且有八間是廣島當地的中小企業。這還真是令人驚訝。

不過這次的議程，在內容方面與 Perl 直接相關的已經減少到一半左右了，可能算是有些偏離主體？但儘管如此，技術方面的主題仍然挺吸引人，並且技術知識的共享方面是共通的。似乎可以不必計較。

贊助商的攤位方面，有十來間到場設攤宣傳的廠商。另我印象比較深刻的是 chocoZAP 這個主打用零碎時間來運動的輕度健身的品牌，竟然也是贊助商（其公司為 RIZAP）。而且也在現場招募。從宣傳單上看來，伺服器端是 Ruby，iOS App 為 Swift，Android 為 Kotlin 這樣的組合吧。宣傳單的背面則是拉人加入健身房會員的廣告了(附折扣碼)（笑）。

另一間另我印象深刻的是 Findy。其主產品是協助軟體團隊能理解開發現況的視覺化輔助工具。跟我在碩士班期間做的題目很像。能給一個團隊一些簡明的圖表來迅速看出目前專案開發的狀態，瓶頸之有無，人員協作的連結度等等。應該比較偏向是給管理階級的人員看的圖資工具。

議程本體方面，總共分成三軌，自然也是等日後看有沒有錄影可以補完。在此先大致上摘要了一些我現場聽到覺得有意思的內容。

〈VISAカードの裏側と “手が掛かる” 決済システムの育て方 by 三谷〉。講者是在 VISA 發卡公司員工。這演講算是業界甘苦談吧。難度核心部份在於要能夠「寬鬆而有彈性地」去處理由 VISA API 呼過來的各種不太合理的內容。講者宣稱在聽完後，大家之後必定會在拿到刷卡對帳單時好好看一下在那張小單據印上的各欄資訊。這是真的。

〈rakulangで実装する! RubyVM by 八雲アナグラ〉。講者探索了如何以 rakulang 製作一個簡單的 Ruby VM，並分享了其摘要。嚴格說起來他做的程式不算是 Ruby VM，因為不能吃 bytecode，只能吃文字格式的組語。但要做出 YARV bytecode 似乎不那麼容易，所以就退而求其次了。是深入淺出，內容豐富的演講。

〈PerlでつくるフルスクラッチWebAuthn/パスキー認証 by macopy〉。講者用 live coding 形式說明了 WebAuthn 協定。概要清晰，有把 WebAuthn 中幾個重點都解釋出來。live coding 最後也成功了。但看來有 80% 左右的程式碼是 Copilot 寫的啊。 （結果 ok 就好）

Keynote 由「とほほのWWW入門」這個網站的作者「杜甫々」來登台。看來是位人人皆知的名人，這網站上所有文件似乎都是他自己編寫的，種類眾多，從軟體技術細節到所得稅法都有著墨。真是不得由衷讓人欽佩：怎麼會有人這麼會寫文件？

伴隨研討會的舉行，同時這次由面白法人主催了個 perlgolf 活動。很久沒玩了，還是頂懷念這種看似胡搞，但卻又能確實達成目的且節節變難的重構過程啊。同時也有種：「這才是 Perl 研討會啊！」的一種爽快感。雖然實務上不會有要把程式碼節節縮短的需要，但對同一個問題反覆進行重構、不斷得出不同風格的解法，不也是一種解決問題所必備的基礎能力嗎？

最近注意到有三個新版連發：

• https://metacpan.org/release/PEVANS/perl-5.38.2/changes
• https://metacpan.org/release/PEVANS/perl-5.36.3/changes
• https://metacpan.org/release/PEVANS/perl-5.34.3/changes

但是內容都一樣，看來是專門為了處理以下兩個 CVE 而發的新版本：

• CVE-2023-47038 - Write past buffer end via illegal user-defined Unicode property
• CVE-2023-47039 - Perl for Windows binary hijacking vulnerability

CVE-2023-47038 的影響範圍是自 5.30.0 (釋出日為 2019/05/22) 到 5.38.0 （釋出日為 2023/07/02）。這範圍不小，得來升級一下。

perl-5.38.0 變更說明： https://metacpan.org/release/RJBS/perl-5.38.0/changes

摘要：

• 內建的物件導向架構的改善：新增 class, field, method 三個定義類別的關鍵字。（實驗性機能。須以 use feature 'class'; 打開。）
• 新增對 Unicode 15.0 的支援。
• 新增：讓 PERL_RAND_SEED 環境變數為程式開跑時的亂數種子值。相當於去呼叫 srand() 。
• 讓語法錯誤訊息更加精簡。
• 自動在模組源碼 (內含 package 或 class 的 .pm 檔案) 最後補上 true
• 內部用的函式的移除與其文件改善。
• 宣告廢棄：smartmatch (given / when)。名稱空間中的 ' 分隔符號。

內建的物件導向架構的改善

這應該是這是兩三年來著力最多的部份吧。比起多數提供在 CPAN 上的 OO 框架，perlclass 相對來說很好懂。有三個新的關鍵字與其帶來的新語意，但是幾乎沒有新的語法規則，至少目前沒有。

參考：perlclass 文件。

三個新關鍵字是：class、method、field。class 用來定義類別。method 用來定義 instance method，field 用來宣告 instance variable。

以 class 定義出來的類別會自動以 new 為其 constructor 函式，並且，所有 instance method 體內皆能以 $self 表示目前物件。class 體內的 instance method 的 signature 則不可包含 $self。

而 class 體內的 sub 可用來定義 class method， class 體內的 my 則可用來宣告 private class variable。 class 體內的 our 則可用來宣告 public class variable。

在同一 class 體內以 my、our、field 宣告出來的諸變數是共用同一個名稱空間的。名稱有衝突的話，只有最後一個變數會被留下。

在同一 class 體內以 sub 與 method 宣告出來的各函式也是共用同一個名稱空間的。名稱有衝突的話，只有最後一個函式會被留下。

以 field 宣告出來的變數為 instance variable，只能被用於 instance method 體內。

以 method 定義出來的函式為 instance method，體內可使用 instance variable，同時亦會自動有 $self 可用來代表目前物件。要呼叫其他同一 class 內的 class method 的寫法與普通函式呼叫相同。要呼叫 instance method 時則是需要對 $self 呼叫。

當做範例，以下是一個描述了五段變速電風扇的簡易類別。

          use v5.38;
use feature 'class';
use builtin 'true', 'false';

class Fan {
    use List::Util qw(min max);

    my $__id = 1;
    my $RPM_MAX  = 600;
    my $RPM_MIN  = 100;
    my $RPM_STEP = 100;

    sub vendor { "Cool Company" }
    sub speeds { ($RPM_MAX - $RPM_MIN ) / $RPM_STEP }

    field $id = $__id++;
    field $rpm = 3600;
    field $on = false;

    method id { $id }
    method speed { $rpm / $RPM_STEP }

    method turn_on  { $on = true }
    method turn_off { $on = false }
    method faster   { $rpm = min($rpm + $RPM_STEP, $RPM_MAX) }
    method slower   { $rpm = max($rpm - $RPM_STEP, $RPM_MIN) }

    method TO_JSON {
        +{
            # instance method / variable
            id      => $self->id(),
            speed   => $self->speed(),
            on      => $on,

            # class method / variable
            vendor  => vendor(),
            speeds  => speeds(),
            rpm_max => $RPM_MAX,
            rpm_min => $RPM_MIN,
        }
    }
}
        

前述以 sub 定義出來的 class method，其實也可以被當成是 instance method 來呼叫。例如 Fan 類別的 vendor ，有兩種呼叫方式：

          my $fan = Fan->new;

say $fan->vendor(); # (1)
say Fan->vendor();  # (2)
        

(1) 與 (2) 兩處對應到的函式是同一個。

以 class 所附的 new 函式所做出來物件，字串形式上會有個 OBJECT 字樣：

          my $fan = Fan->new;
say "$fan";

#=> Fan=OBJECT(0x19477b0);
        

如果是以常見的 blessed HashRef 做法 (即：bless {}, 'Fan') 所造出來的物件，其字串形式是這樣：

          Fan=HASH(0x1b3a5e8)
        

由此可窺知在 perl 內部多了一種以 OBJECT 為表記的值。

自動在模組源碼最後補上 true

以往都要在 .pm 檔案最後補個 1;，然後還得向人說明這行看似無作用的程式碼的用途。以後在開頭加上 use v5.38; 後就不必在檔尾補 1 了。

          # Foo.pm
use v5.38;
package Foo {
    sub foo() { "Bar" }
}
        

附帶一提，就算在最後在 Foo.pm 最後故意加上 0;，也不會讓 use Foo; 失敗。

在 reddit.com/r/perl 板上看到 pmz 問了這樣子的一個問題：

XML::Twig, get value (or not) without dying

Currently I do:

if (defined $elt->first_child('addr')->first_child('postalCode')) {
  $patient{patient_postal_code} = $elt->first_child('addr')->first_child('postalCode')->text ;
}

because if I don't check for "defined" and the resulting value is null , it dies.

原文連結： https://www.reddit.com/r/perl/comments/1492sc1/xmltwig_get_value_or_not_without_dying/

這一方面是在針對 XML::Twig 模組的用法提問，另一方面是在問：當 first_child('addr') 傳回 undef 時，表示在目前 XML 文件樹中沒有 addr 元素，而後o方的連環呼叫 first_child('postalCode') 之處就會讓程式執行中斷，因為原本預期是物件的地方，也有可能是 undef。那有沒有能讓連環呼叫不會使程式失敗，並且在遇到 undef 時，讓整串算式的結果成為 undef 的辦法？

如果把題目重新描述得較抽象一些的話，就是：假設有一類別，其下有方法 a()、b()、c()。這三個方法可能會傳回 undef 或同一類別的物件。今有一物件 $o 屬此類別，考慮此連環呼叫式：

$res = $o->a()->b()->c();

此式在 a() 或 b() 傳回 undef 時，就會讓程式中斷，並會出現像這樣的錯誤訊息：

Can't call method "c" on an undefined value

亦即：無法對 undef (undefined value) 呼叫 "c" 這個方法。這是當然的，因為 undef 並非物件。

試問：有何手段能改寫此式，能避免前述錯誤之發生，使 $res 在 a()、b()、c() 任一者傳回 undef 時就算得 undef，且在全無 undef 情況下，又能正確算得 c() 的傳回值？

在一些語言中，這可輕易得透過使用 safe-navigation operator 或 optional chaining operator 來解決。例如 javascript 或 kotlin 中的 ?.：

res = o.a()?.b()?.c();

又例如 raku 語中的 .?:

$res = $o.a().?b().?c();

但直到目前 perl 5.38 為止，在 perl 語言中尚未出現同等作用的算符。

有個直觀的改寫方式是像這樣：

$res_a = $o->a();
$res_b = $res_a && $res_a->b();
$res   = $res_b && $res_b->c();

但在讓程式變長、用了多個臨時變數而讓程式碼變得稍微不好讀之外，這改寫法還不通用，碰到類似結構、名稱不同的式子就得手動從頭改寫。實在算不上是好辦法。

此外，有個超間單的改寫方法：

$res = eval { $o->a()->b()->c() };

但是，這個寫法的副作用，就是所有例外事件通通都會被忽略，雖然簡單好改，但其副作用很強。不見得在各種情境都適合。

在此提供一個以 Monad Design Pattern 來達成得的一個解法。

改寫方法如下：

$res = SafeNav->wrap($o) ->a()->b()->c() ->unwrap();

其中 SafeNav 的定義為：

use v5.36;
package SafeNav {
    sub wrap ($class, $o) { bless \$o, $class }
    sub unwrap ($self)    { $$self            }

    sub AUTOLOAD {
        our $AUTOLOAD;
        my $method = substr $AUTOLOAD, 2 + rindex($AUTOLOAD, '::');

        my ($self, @args) = @_;

        # [a]
        (defined $$self) ?
            __PACKAGE__->wrap( $$self -> $method(@args) ) :     # [a.1]
            $self;                                              # [a.2]
    }

    sub DESTROY {}
};

這類別基本上是把所有純量值都包裝成物件。SafeNav 類別定義有 AUTOLOAD 這個特殊用途的函式，使其物件可接受所有方法呼叫。就算包著的值是 undef 方法呼叫也都不會失敗，而是會進入 AUTOLOAD 函式中。

於是在 [a] 處就可進行核心處理：若自己包著的值不是 undef，就對其呼叫原方法（[a.1] 處）。倘若自己包著的值已經是 undef 了，那繼續躺平做自己(?)就可以了（[a.2] 處）。

多虧有 AUTOLOAD 機制，原連環呼叫 ->a()->b()->c() 的部份是原樣保留著的。在此並列、比較一下：

$res = $o ->a()->b()->c();
$res = SafeNav->wrap($o) ->a()->b()->c() ->unwrap();

前後的 wrap() 與 unwrap() 算是明確界定了 SafeNav 類別在此式中的作用範圍。過了 unwrap() 之後如果還繼續串著更多方法呼叫，就一定不是被包在 SafeNav 裡面的。

這麼一來，會被「妥善忽略」的，就只有在碰到 undef 這個值的時候。若在 a、b、c 三個方法內發生了任何例外事件，程式還是能正確地被中止。並不會有太多副作用。在本文內提到的三種改寫辦法裡面，算是既通用，又不太囉唆的一種。

Recently on reddit.com/r/perl, pmz posted a question like this:

XML::Twig, get value (or not) without dying

Currently I do:

if (defined $elt->first_child('addr')->first_child('postalCode')) {
  $patient{patient_postal_code} = $elt->first_child('addr')->first_child('postalCode')->text ;
}

because if I don't check for "defined" and the resulting value is null , it dies.

Link to the original post: https://www.reddit.com/r/perl/comments/1492sc1/xmltwig_get_value_or_not_without_dying/

While on one hand the question is about how to use XML::Twig, on the other hand the obvious inconvenience here is when first_child('addr') returns undef, which means there are no <addr> element underneath, the following call of first_child('postalCode') would make the programm die. Generally speaking: in a chain of calls we expect objects to be present in all positions, but sometimes there are undef. Given that, is there a way to avoid the program from dying and let the entire call chain return undef if undef is encountered in the calling chain ?

To formalize the question a bit more generically: assume a class with instance methods a(), b(), and c(). These methods may return an instance of same class, or ocassionally, undef. Consider the following chain of calls originally from $o:

$res = $o->a()->b()->c();

In case any of a(), b(), or c() returns undef, the program dies with messages like this:

Can't call method "c" on an undefined value

Which suggests b() returns undef and since undef is not an object, we cannot call methods on it.

Now, could we rewrite the same program to prevent the abovementioned error from happening, while making $res be undef if any of a(), b(), c() returns undef, or otherwise, the return value of c() ?

In some other programming languages, such purpose could be satisfied by using the safe-navigation operator, such as ?. in javascript or kotlin:

res = o.a()?.b()?.c();

Or in raku, .?

$res = $o.a().?b().?c();

However, we haven't seen anything similar up until perl 5.38 just yet.

A rather intuitive way to rewrite would be something like this:

$res_a = $o->a();
$res_b = $res_a && $res_a->b();
$res   = $res_b && $res_b->c();

However, besides making the program much longer and less easier to grasp, the rewrite is not generic. It'll be different for similar statements with different method names. Not a good strategy.

Meanwhile, here's a super simple and generic way:

$res = eval { $o->a()->b()->c() };

However, with the powerful side-effect of eval, all exceptions would be ignored while we are only interested in ignoring undefined values. That is a lot more than what we want. Even though it looks simple, it is probably not applicable.

Here is a solution with Monad design pattern.

The rewritten version looks like this:

$res = SafeNav->wrap($o) ->a()->b()->c() ->unwrap();

The SafeNav is defined as the folowing.

use v5.36;
package SafeNav {
    sub wrap ($class, $o) { bless \$o, $class }
    sub unwrap ($self)    { $$self            }

    sub AUTOLOAD {
        our $AUTOLOAD;
        my $method = substr $AUTOLOAD, 2 + rindex($AUTOLOAD, '::');

        my ($self, @args) = @_;

        # [a]
        (defined $$self) ?
            __PACKAGE__->wrap( $$self -> $method(@args) ) :     # [a.1]
            $self;                                              # [a.2]
    }

    sub DESTROY {}
};

SafeNav is a class that wraps all scalar values and equips with AUTOLOAD for responding to all method calls.

Inside AUTOLOAD there is the core part of our logic in [a]: If we are not wrapping an undef value, we call the original method on it, then re-wrap the return value ([a.1]). Or if we are wrapping an undef, we ignore the method call and just lay down and keep being ourselves ([a.2]).

Thanks to the mechanism of AUTOLOAD, the original form of ->a()->b()->c() is kept exactly the same after the rewrite. Let's put both versions side-by-side for a quick comparison:

$res = $o ->a()->b()->c();
$res = SafeNav->wrap($o) ->a()->b()->c() ->unwrap();

The wrap() at the front, together with unwrap() at the back, form a clear boundary in which SafeNav is effective. Method calls after unwrap() are not not guarded by SafeNav.

With that, we properly ignore undef values, nothing more. If other kinds of exceptions are thrown from method a, b, c, the program would correctly abort. In the 3 proposed ways to rewrite the program in this article, the SafeNav monad is both generic and not adding too much verbosity to the original program.

最近開始看到 Perl Toolchain Summit 的結果了。稍微讀了一下，以此篇文章綜合摘要一下今年在 Perl Toolchain 那裡的幾項決定（Lyon Amendment）：

• 原則上 toolchain 內的軟體 (註1) 會開始追上 (註2)「十年前」的 perl 版本。(註3)
• 唯 2023 年例外，爲了提供給 RedHat v7 終活服務(?)而定爲 5.16。
• 明年 (2024) 定爲 5.20、後年 (2025) 定爲 5.22... （註4)

如果有經常性在升級 perl 的話應該是不會因此受到甚麼影響。主要會被影響到的應該是一些因故無法升級的老系統，最糟有可能會變成不能使用 cpan 指令來安裝模組、或是有某些重要的模組在某版之後變成無法編譯、要使用的話就必須固定使用某個舊版。在老系統上安裝新模組的需求一般來說通常倒是安全性更新。考慮到作業系統本身也需要被更新，讓 Perl / CPAN 相關工具以類似作業系統更新的步調去「與時俱進」似乎還算是合理的。

註：

1. 主要是與 CPAN 生態系相關的各項工具與模組。包括模組的製作、測試、釋出、CPAN 伺服器端用的軟體等等。
2. 原文用 "track" 這個字。這裡應該是指「如果在老於十年的 perl 環境內跑出錯誤也不再修理」的意思。
3. 2013 年釋出的穩定版爲 5.18。
4. perl5 穩定版版號是每年往上加 2，並必定爲偶數。類似 Linux 的慣例。

參考：

1. PTS 2023: The Lyon Amendment (minimum perl) (2/5) by rjbs
2. lyon-amendment.md

簡單筆記一下。以 Debian 爲例。

在安裝 DBD::mysql 時需要 mysql_config 這個指令，但如果要使用 MariaDB Client 而不能安裝 MySQL Client 時，也可以讓 DBD::mysql 去使用 mariadb_config，使其改與 libmariadb 連結。由於 MariaDB Client 也可以用來與 MySQL Server 溝通，在不想額外加入 mysql 套件的時候也可以使用這招來省點事。

首先需要裝好開發與編譯用的函式庫：

          sudo apt-get install libmariadb-dev

        

然後是在安裝 DBD::mysql 時，透過指定環境變數的方式，讓其在編譯過程去使用 MariaDB 的編譯設定：

以 cpm 指令來裝

          DBD_MYSQL_CONFIG=/usr/bin/mariadb_config cpm install -g DBD::mysql

        

以 cpanm 指令來裝

          DBD_MYSQL_CONFIG=/usr/bin/mariadb_config cpanm DBD::mysql

        

以 cpan 指令來裝

          DBD_MYSQL_CONFIG=/usr/bin/mariadb_config cpan -i DBD::mysql

        

以上。

https://metacpan.org/release/GUGOD/PerlX-ScopeFunction-0.03

好幾年前我擅自開始把 PerlX:: 這個 namespace 當成是「Perl 語言的延伸」的 意義在使用，並且做了一些有的沒的新語法。最近這星期做了 PerlX::ScopeFunction。

這個模組提供兩個新的語法關鍵字: let 與 with。

先看範例，就能大致上掌握這兩個關鍵字的用法：

          use v5.36;
use List::Util qw( sum0 );
use List::MoreUtils qw( part minmax );
use PerlX::ScopeFunction qw(let with);

my @input = (3,1,3,3,7);

let ( ($min,$max) = minmax(@input); $mean = sum0(@input)/@input ) {
    say "$min <= $mean <= $max";
}

with ( part { $_ % 2 } @input ) {
    my ($evens, $odds) = @_;
    say "There are " . scalar(@$evens) . " even numbers: " . join(" ", @$evens);
    say "There are " . scalar(@$odds) .  " odd numbers: " . join(" ", @$odds);
}

        

這兩個關鍵字提供了一種可以將幾個指定變數的語義範圍縮限起來的方式。前述範 例中 let 語句所造出的 $min、$max、$mean 三個變數的語義範圍是在後方的區塊 之內。with 語句則是能將一個算式取值，並把結果裝入 @_ ，使其能在後方的區塊內使 用。

這兩種語法結構都是從其他語言借過來的，在 Perl5 目前的語法中，最類似的是 sub closure 與 do：

          sub {
    my ($evens, $odds) = @_;

    ...
}->(part { $_ % 2 } @input);


do {
    my ($min,$max) = minmax(@input);
    my $mean = sum0(@input)/@input;

   ...
};

        

而 PerlX::ScopeFunction 所做的就是提供一些新關鍵字，讓這種特殊片語寫起來 更加明瞭一些，也利於解讀。

一陣子之前看到的。 cpan-outdated 這個指令，能列出所有可升級的模組。

它的輸出格式看來是 CPAN Mirror 底下的路徑。可以直接餵給 cpanm 去安裝。

          # cpan-outdated | head
P/PL/PLICEASE/Alien-Build-2.76.tar.gz
P/PL/PLICEASE/Alien-Libxml2-0.19.tar.gz
T/TO/TOKUHIROM/Amon2-6.16.tar.gz
R/RJ/RJBS/App-Cmd-0.335.tar.gz
O/OA/OALDERS/App-perlimports-0.000049.tar.gz
R/RJ/RJBS/App-Uni-9.006.tar.gz
P/PJ/PJACKLAM/bignum-0.66.tar.gz
L/LE/LEEJO/CGI-4.55.tar.gz
G/GA/GARU/Clone-0.46.tar.gz
P/PM/PMQS/Compress-Raw-Bzip2-2.201.tar.gz
        

此外既有的 cpan 指令也能做到類似的事：執行 cpan -O 後，會列出各模組的目前版號以及最新版的版號。

          # cpan -O | head -15
Reading '/home/gugod/.cpan/Metadata'
  Database was generated on Thu, 05 Jan 2023 00:54:02 GMT
Module Name                                Local    CPAN
-------------------------------------------------------------------------
CPAN: Module::CoreList loaded ok (v5.20220520)
Acme::CPANAuthors::Austrian               1.1318  1.1318
Alien::Base                               2.5100  2.7600
Alien::Base::PkgConfig                    2.5100  2.7600
Alien::Base::Wrapper                      2.5100  2.7600
Alien::Build                              2.5100  2.7600
Alien::Build::CommandSequence             2.5100  2.7600
Alien::Build::Interpolate                 2.5100  2.7600
Alien::Build::Interpolate::Default        2.5100  2.7600
Alien::Build::Log                         2.5100  2.7600
Alien::Build::Log::Abbreviate             2.5100  2.7600
        

但看來 cpan -O 列出的是 package 而 cpan-outdated 列出的是 distribution。 不過也可執行 cpan-outdated -p，讓它改列 package 名。

如果只是要無條件全部升到最新版的話，可以執行 cpan -U 或是 cpan-outdated | cpanm。

幾年之前我開始把例假日的列舉做成模組、發佈到 CPAN 上面去。也就是名爲 Date::Holidays::TW 這個模組。這個模組基本上是帶有簡單 API 的資料集，能讓人查詢某年某月某日是否爲國定假日。所參考的資料來源有兩項：

一是行政院人事行政總處的「政府行政機關辦公日曆」，也就是在這個網址裡可以找到的某個頁面： https://www.dgpa.gov.tw/informationlist?uid=30

二是在政府開放資料平台上所找到、名爲「中華民國政府行政機關辦公日曆表」的這個資料集： https://data.gov.tw/dataset/14718 。這資料集的格式是 CSV 格式，因此主要是以此做爲資料源，再以辦公日曆來對答案。

而維護這模組主要的難處在於中華民國政府所定義的假日並不容易以計算的方式得知。因此無法製作單一一套演算法來一勞永逸。必須每年花點時間將資料匯入。而這之所以不容易計算，乃是因爲其規則有部分曖昧成分。

以下將中華民國一百一十二年政府行政機關辦公日曆表所節錄的放假與補假規則稍微摘要後列出：

• a. 紀念日及節日之放假日逢例假日應予補假。例假日為星期六者於前一個上班日補假，為星期日者於次一個上班日補假。但農曆除夕及春節放假日逢例假日，均於次一個上班日補假。
• b. 下列紀念日及節日放假
  • 中華民國開國紀念日（一月一日）
  • 和平紀念日（二月二十八日）
  • 國慶日（十月十日）
  • 春節（農曆一月一日至一月三日）
  • 民族掃墓節（定於清明日）
  • 端午節（農曆五月五日）
  • 中秋節（農曆八月十五日）
  • 農曆除夕（農曆十二月之末日）
  • 原住民族歲時祭儀：各該原住民族放假日期，由原住民族委員會參酌各該原住民族習俗公告，並刊登政府公報。
  • 兒童節（四月四日）
• c. 紀念日及節日之放假日逢例假日應予補假。例假日為星期六者於前一個上班日補假，為星期日者於次一個上班日補假。但農曆除夕及春節放假日逢例假日，均於次一個上班日補假。
• d. 上班日為星期一或星期五，其後一日或前一日逢星期二或星期四之紀念日及節日之放假，調整該上班日為放假日。農曆除夕前一日為上班日者，調整該上班日為放假日。

資料內容主要是計算出規則 b 內各項紀念日及節日所對應到的西曆日期。除了有三項爲農曆日期之外，其中「清明節」本身的計算需要將一農曆年等分，或是使用各數學家推出的近似公式解。

只是，前述假日規則之外還有個「補班」規則，也就是有幾個原本爲放假日的星期六有可能會被變爲上班日。這補班規則是列在 政府機關調整上班日期處理要點 的第五條：

五、因應連續假期所為之上班日調整，除特殊情形者外，以提前於前一週之星期六補行上班為原則。

也就是說，以前述規則 a、 c、 d 所做出來的補假日或放假日（通常是星期一或星期五）所形成的連續假期，會讓其之前一週的星期六有可能會變成上班日，或稱「補班日」，但也有可能不會。在規則上以「特殊情形」這個用詞留下了一些曖昧空間。

再者，由於出現上班日，使其可能會成爲假日規則中的「前一個上班日」與「次一個上班日」所指涉的目標。也就是說這幾條規則的套用次序會直接影響到結果。而任何人獨自實做出來的程式碼，對於前述幾條規則的解釋與規則套用次序的理解，都有可能不同於行政院人事行政總處的解釋。

比方說以 2023 年假日的幾個補班例子來看，若以 中華民國一百一十二年政府行政機關辦公日曆表圖檔 爲準，可看到 6/17 星期六爲上班日，而其次星期的 6/23 星期五爲假日，因爲 6/22 爲端午節，是假日。這部分就符合補班規則裡「提前於前一週之星期六補行上班」這半句的描述。

但若看到 3/25 星期六，也是上班日，而且其次星期一 (3/27) 到星期五 (3/31) 則全是上班日，反而是八天後的 4/3 星期一爲放假日。可知這一日的補班，並非是「於前一週之星期六」，而是「於前二週之星期六」了。可另於 2/18 及 9/23 看到類似狀況。或許這可算是某種「特殊情形」。

由 2023 年的這幾個例子來推敲，似乎可得知實際的規則如下：如果某星期一被調爲放假日，則其八天前的星期六應被調爲上班日。而若某星期五被調爲放假日，則其六天前的星期六應被調爲上班日。

但若看到一月份：1/7 星期六爲上班日，而與其對應的放假日應爲 1/27 星期五。1/27 被調整爲放假日，但其六天前的週六爲農曆除夕，本爲假日、不應該被調爲上班日。因此，或許與 1/27 對應的補班日爲 1/14 星期六。但是我的推算與行政院人事行政總處不同。顯然這就是規則中所謂的「特殊情形」了。

所以爲了求模組的正確性，就不能只依靠計算，還必須定時把公佈的假日表複製一份到 Date::Holidays::TW 這模組裡面去才可以。看來做月曆或手帳的業者也是無法在公佈之前自行計算出正確的補班日，每年都要手動進行這一例行公事才行。

附帶一提，似乎從沒看過這表內出現任何由原住民族委員會所定義的假日。

偶然讀到 ~nicholasbhubbard 的文章，發現在調整 Emacs 方面跟我最近的做法有點類似。至少主要幾項重點都一樣。

使用 Emacs 28 內附的 cperl-mode.el

如果系統內的 Emacs 比 28 還舊，就取 emacs.git 抓一份新的 cperl-mode.el 回來用。

縮排以四格爲單位

且避免讓跨行的 () 內容過度縮排。如果一樣是以四格爲單位，寫 lisp 時的慣例是跨行 S-exp 的內容縮到比其左括號更進一級的位置。如果左括號位置在 n，那下一行至少是 n + 4。但這條規則用來替 C / Perl 縮排的話真的會怪怪的。總合起來最少需要調整三個變數：

          (setq cperl-indent-level 4)
(setq cperl-indent-parens-as-block t)
(setq cperl-close-paren-offset (- cperl-indent-level))
        

在排程式碼之時基本上都是讓 cperl 以其自己的規則去排。但最近在試用 format-all + perltidy。perltidy 似乎對不少特定類型的程式碼沒轍，也太好調整（個人意見），雖然斷斷續續有在用，但是一直沒有調出一組夠好的參數。最近在考慮於 CI 中讓 reviewdog 去跑 perltidy，試著讓縮排風格不同的大家至少能避免在這件事上花去太多討論時間。以滿足協作這個目的而言，也有採用 editorconfig。

format-all 的好處它一律依靠外部工具來縮排，完全不依靠 Emacs 本體。而那外部工具基本上就是個社群已經熟悉的工具。若是 cperl-mode 則用 perltidy，若是 kotlin-mode 則用 ktlint。所以如果有人用 vim，也不會在縮排設定這件事情上面產生不必要的變更。

          (use-package format-all
  :config
  (add-hook 'prog-mode-hook 'format-all-mode))
        

在專案內遊走（code navigation）

目前覺得最好用的是 rg + dumb-jump。有嘗試使用 language server，不過還沒讓它成功過。至少依照原文件來弄的話，無法直接在我的系統中管用。猜想是跟 perlbrew 環境慣例不太合拍。但尚無仔細除錯下去的打算。rg + dumb-jump 基本上就又快又好用了。

我用 use-package，與 dumb-jump 相關的設定就這幾行：

          (use-package dumb-jump
  :config (add-hook 'xref-backend-functions #'dumb-jump-xref-activate)
  :custom (dumb-jump-selector 'ivy))
        

而目前在以檔名找檔案是使用 fzf：

          (use-package fzf
  :bind ("C-c f" . my/fzf-current-project))
        

開終端機

要跑指令時，目前是用 vterm + vterm-toggle 與系統上的隨便甚麼終端機混用。vterm 相關的設定爲這幾行：

          (use-package vterm)
(use-package vterm-toggle
  :bind
  ("s-'" . 'vterm-toggle)
  ("H-'" . 'vterm-toggle)
  :custom (vterm-toogle-fullscreen-p t))
        

綁了兩組不同的呼叫鍵給 vterm-toggle 函式的原因是讓 macOS 與 Linux 上都能通用。在同一把 Atreus 鍵盤 上，s-' 與 H-' 都是代表同樣的兩個鍵。只是同一個鍵碼在 Linux 上被抓成 s-'，在 macOS 上則對應到 H-'。

結論

跟許多人一樣，我有點用不慣那種會主動在畫面上提供一大堆提示的編輯器 / IDE。我覺得那很讓人分心，如果不小心點到，還得想辦法恢復原狀。因此在 Emacs 的設定方面，一向都也是維持精簡。長年下來這套設定大致上很管用。雖然不見得能讓電腦提供最大程度的協助，但是能夠把一些瑣瑣碎碎的小問題變不見就很有幫助了。

數謎 (Cryptarithm) 是種算數謎題，謎面是由三個以上的英文單字所寫成的一個算式，其中每個字母都對應到一個自零至九之間的數目字。通常以直式寫出，例如這個經典範例：

            SEND
+ MORE
------
 MONEY

        

解謎者需要推敲出每個字母所對應的數目字，使算式成立。一個比較簡單的範例是：

            SO
+ SO
----
 TOO

        

應該不難看出有 S = 5, T = 1, O = 0 這組解。而大部分數謎都是透過讓字母的重複出現，而設計成只有一組解。

如果有個謎面是 AB + CD = EF，每個字母都只用過一次，那就隨意令 AB=12 且 C=3，馬上就可讓謎面簡化成 12 + 3D = 4F 從而得到 D=5 且 F=7。也就是 12 + 35 = 47 這組解。而且再將前面兩個數字對調，成 35 + 12 = 47，又是另一組解。

也就是說如果重複字母很少，讓自由度太高，反而會使題目變得過於簡單。

要手動解這種謎題，可先試著找出明顯的部分解答，將謎面簡化。以 SEND + MORE = MONEY 爲例，慣例上可排除 S=0 與 M=0，因爲數字首位不會是零（不過也有允許首位爲零的玩法）。此外，很明顯的部分解答是 M = 1：因爲兩個相異的個位數字相加，最大可得 17 (= 9 + 8)，就算再加上進位，也只會得到 18。也就是說 M 只有可能是 1 。因此可得到 SEND + 1ORE = 1ONEY 這個稍微簡化一些些的謎面。同時，既然 M 對應到 1，那表示其他所有字母都不可能是 1。

下一步或許是考慮 S + 1 + 進位 = 1O。個位數字中加了 1 就會進位的只有 9。再考慮進位可能爲 1 或 0，則 S 只可能是 9 或 8。在此出現條件分歧，可在假設 S=9 的前提之下，繼續找出其他字母對應。

也就是這個謎題基本上是個搜尋問題。在排除掉一些明顯不對的選項之後，解謎者必須逐個嘗試。配合運算規則所帶來的限制，將衆多選項一一排除，最後無法被排除而留下來的，就是解答了。

這種謎題是個很適合用來以程式做搜尋演算法的題目。搜尋範圍就是謎面中用到的所有字母所對應到的數目字之組合與排列。

對此，我想了個遞迴解：

          sub decryptarithm (
    $cryptExpr,
    $letters         = [ distinctLetters $cryptExpr ],
    $isNonZeroLetter = +{ map { $_ => true } firstLetters $cryptExpr },
    $digitFromLetter = +{},
    $digitAssigned   = +{},
) {
    my $unboundLetter = first { !exists $digitFromLetter->{$_} } @$letters;

    # (1)
    unless ( defined($unboundLetter) ) {
        my $plainExpr = plaintextfy( $cryptExpr, $digitFromLetter );
        my $evalExpr  = $plainExpr =~ s/=/==/gr;

        # (2)
        return eval( $evalExpr ) ? $plainExpr : ();
    }

    # (3)
    my @possibleDigits = grep { not $digitAssigned->{$_} } ( ( $isNonZeroLetter->{$unboundLetter} ? 1 : 0 ) .. 9 );

    map {
        decryptarithm(
            $cryptExpr, $letters, $isNonZeroLetter,
            +{ %$digitFromLetter, $unboundLetter, $_ },
            +{ %$digitAssigned,   $_,             true },
        )
    } @possibleDigits;
}
        

其中 $cryptExpr 就是謎面，以字串形式保存，如 "SEND + MORE = MONEY"。

在 (1) 處先處理終端條件。當 $unboundLetter 爲未定義的時候，也就是所有字母都已經有所對應的時候。這時就是依照 $digitFromLetter 這個對應表，把 $cryptExpr 明文化，得到 $plainExpr，並在 (2) 處，則是明文版本做出來後，簡單以 eval 來判別算式成立與否，如果成立，表示 $plainExpr 是一組解，得傳回，如果不成立，則傳回空的串列。

在 (3) 處，表示在 $unboundLetter 變數中所存的字母是還沒有與任何數字對應的，此時需列舉出能與這個字母對應的所有數目字，逐一遞迴嘗試。

這基本上就是個暴力搜尋的過程，除了通過 $isNonZeroLetter 來排除 0 之外，沒有寫入任何其他排除搜尋路徑的算式。是個很耗時間演算法。如果要做其他種類的排除，就必須先知道 $cryptExpr 內容是做加減乘除的那一項，再依照運算規則推敲出幾種排除規則。想來是需要不少算式才能描述得清楚。

這個解謎函式會找出謎面 $cryptExpr 的所有解答。若要讓它找第一組解後就停，那把最末的 map 改成 first 應該就可以了。

在不同的職場裡面都已經看過好幾次了。總是會有人用正規表示式：

          $s =~ /\Afoo|bar\z/

        

... 來意圖檢查 $s 是否為 "foo" 或 "bar"。

但是這正規表示式能比對到字串不只兩個，而是無限多個。

正規表示式 \Afoo|bar\z 代表的是「所有以 foo 開頭的字串」與「所有以 bar 結尾的字串」兩集合的交集。而不是 {"foo","bar"} 這個只有兩個字串的集合。

要滿足原意圖，必須補上小括號，但不要把 \A 與 \z 括入：

          $s =~ /\A(foo|bar)\z/

        

一般來說我認為，若用了 | ，就要同時加上小括號來明確區分出範圍，不然很容易造成誤讀。如果是明確寫成：

          $s =~ /(\Afoo|bar\z)/

        

也可真正顯示出作者意圖真的就是要測試 $s 是否是「以 foo 開頭的字串」或是「以 bar 結尾的字串」。

附帶一提，以測試 $s 是否等於某些特定值來說，改用 eq 加上 any 來寫或許更能正確地彰顯出作者意圖。

看是要用 List::Util 的 any:

          use List::Util qw(any);

any { $s eq $_ } qw(foo bar)

        

或是 any Junction:

          use Quantum::Superpositions qw(any);

$s eq any( qw(foo bar) )

        

都是不錯的，也不太容易不小心寫錯。

Perl 語言中的正規表示式引擎在經過歷年來的擴充與改進，已經變成一種十分驚人的狀態機了，其能力遠超過教科書上所描述的「正規表示式」太多，基本上可以已經可以用來定義文法規則，並且可以直接而拿來定義一個遞歸下降解析器。

在拜讀 perlre 文件、Damian Conway 的 PPR 程式碼以及 Tom Christiansen 在 stackoverflow 上的幾篇文章之後，就想說來隨便找個語言來做個解析器看看。沒想到不太困難。

我用來學習這部分的對象是 JSON -- 是個已經很熟悉的小語言，並且在 json.org 首頁上就直接就有完整的文法規則可用。我不必費心定義，只要翻譯就可以了。

以下這個 $JSON_GRAMMAR 變數，裝的就是可以解析一個 JSON 文件的語法規則。除了有些不太尋常的括號之外，基本上就是與 json.org 上提供的語法規則逐一對應而已。

          my $JSON_GRAMMAR = qr{
    (?(DEFINE)
        (?<JSON>       (?&element) )
        (?<object>     (  { (?&ws)  }   |  { (?&members) }) )
        (?<array>      ( \[ (?&ws) \]   | \[ (?&elements) \] ) )
        (?<elements>   ( (?&element) | (?&element) , (?&elements)) )
        (?<members>    ( (?&member)  | (?&member) , (?&members) ) )
        (?<element>    (?&ws) (?&value) (?&ws))
        (?<member>     (?&ws) (?&string) (?&ws) : (?&element) )
        (?<value>      ( (?&object) | (?&array) | (?&string) | (?&number) | true | false | null ) )
        (?<number>     (?&integer) (?&fraction) (?&exponent) )
        (?<integer>    ( (?&digit) | (?&onenine) (?&digits) | - (?&digit) | - (?&onenine) (?&digits) ) )
        (?<digits>     ( (?&digit) | (?&digit) (?&digits) ) )
        (?<fraction>   ( | \. (?&digits) ) )
        (?<exponent>   ( | e (?&sign) (?&digits) | E (?&sign) (?&digits) ) )
        (?<sign>       ( | \+ | - ) )
        (?<digit>      ( 0 | (?&onenine) ) )
        (?<onenine>    [123456789] )
        (?<string>     " (?&characters) " )
        (?<characters> ( | (?&character) (?&characters) ) )
        (?<character>  ( [^\"\\] | \\ (?&escape) ) )
        (?<escape>     ( \\ | ["bfnrt/] | u (?&hex)(?&hex)(?&hex)(?&hex) ) )
        (?<hex>        ( (?&digit) | [abcdef] | [ABCDEF] ))
        (?<ws>         ( | \x{0020} (?&ws) | \x{000A} (?&ws) | \x{000D} (?&ws) | \x{0009} (?&ws) ) )
    )
}x;
        

可以配合 m// 運算符來使用：

          if ($text =~ m/ $JSON_GRAMMAR \A (?&JSON) \z/x) {
    say "Valid JSON!";
} else {
    die "Invalid JSON";
}
        

可以看到基本上 $JSON_GRAMMAR 內是一個很大的 (?(DEFINE) ... ) 結構。這個 DEFINE 關鍵字，就是用來定義各條可重複利用的語法規則。而且，還可以遞迴。

每條語法規則最左邊 ?<...> 這組括號內的字是這規則的名字，而右側則是這條規則所對應到的正規表示式。其中 (?&...) 這種括號表示參照到某一條規則。可以參照到其他條規則，也可參照到目前這條規則。規則定義的次序似乎不影響結果，只要在同一個 (?(DEFINE) ... ) 結構內就可以。

像是能對應到 JSON 中數字的名爲 number 的這條規則，就是定義爲： integer 後接 fraction，再接 exponent。

          (?<number>     (?&integer) (?&fraction) (?&exponent) )
        

熟悉 yacc 的話可能會覺得這語法真是拖泥帶水，各種環綴符號真是有夠礙眼的。不過仔細閱讀一陣子之後還算可以理解。

但既然這本身是一條正規表示式，其實有不少部分可以直接使用正規表示式與生俱來的咒力(?)來處理。比方說這條規則表示：空字串或加號或減號：

          (?<sign>       ( | \+ | - ) )
        

其實可以簡化成：

          (?<sign>       [\+\-]? )
        

或是這種表示一個以上的 digit 重複出現的規則：

          (?<digits>     ( (?&digit) | (?&digit) (?&digits) ) )
        

其實就等同於於：

          (?<digits>     (?&digit)+ )
        

比起 Raku Grammar 或是 yacc 等能生成解析器產生器的工具而言，要習慣這個語法大概會要多花一點時間。但可以看到 Perl 的正規表示式這個語言真的完全長成另外一支語言，也完全超出了一般教科書上的規格了。而既然可以完整解析一個語言，也就可以做出編譯器，在碰到各條規則時採取相對應的行動。這方面需要在正規表示式中內嵌 Perl 程式碼，等日後再研究看看。

看來應該是伴隨 Unicode 14.0 而一併出現的機能。

所謂的 paired delimiters 指的是像 ()、[]、{} 這種兩個一組的符號。可以配合 q 運算符來把字串括住，也就是所謂的「括號」。除了單引號 '' 雙引號 ""，透過 q 運算符就可以使用各式各樣的半形字符（字碼在 127 以下的）來當括號。

          say 'It\'s a beautiful day.';
say q(It's a beautiful day.);  # 意義同上。或許比較好讀一些。

#=>
# It's a beautiful day.
# It's a beautiful day.
        

這種設計會出現的主要理由，是讓人便於在程式碼中定義各種內含括號的字串。普遍來說程式碼中的字串內容如果帶有符號，尤其是括號，就要以倒斜線字符 \ 來「跳脫」。如果以單引號 ' 來括，字串內的單引號就前就得加上跳脫字符 \。

自 Perl v5.36.0 起，perldoc feature 內多了一段 extra_paired_delimiters 。看來是讓 Unicode TN39 內所定義的成對刮號都可以拿來當原始碼中的字串括號使用。但是，除了一般寫文章會用到的幾組全型括號 「」、『』、〖〗之外，還有許多不太尋常的選項：

          use v5.36;
use utf8;
use feature 'extra_paired_delimiters';

say q🔊電腦說：「你好，今天真是不錯。」🕪;
say q🖝怎麼這樣？🖜;
say q𝄆𝄞🎵這個字串𝄀𝄿不𝄿會自𝄀動反覆🎶𝄇 ;

#=>
# 電腦說：「你好，今天真是不錯。」
# 怎麼這樣？
# 𝄞🎵這個字串𝄀𝄿不𝄿會自𝄀動反覆🎶
        

可用來當左右括號的字符列表很長，在 perldoc feature 文件中有完整列出。

稍微翻了 perl5.git commit 記錄，看來有許多額外追加進去，而不在 Unicode TN39 列表內的符號。

但既然至少是包含了 Unicode TN39 這定義，可以想見未來或許會隨著 Unicode 本身的演進而演進。而這些括號字符的字碼幾乎全部都在 127 以上，也就是說如果不在源碼開頭加上 use utf8;，其實也是無法真正拿那些字符出來用的。

粗略想起來，我真的很少需要在程式碼中寫很大量的字串。需要內嵌大量「滿是括號」的字串的機會更是很少。理論上最有可能發生的時機大概就是要在 Perl 程式碼中內嵌帶 Vue 變數的 HTML，而其內容還是中文小說的狀況。這麼狀況下 <>, "", '', {}, 「」, 『』 說不定真的會同時出現在字串內。而讓人會想要使用 🖝🖜 來當括號......

總之，若能夠少寫一些跳脫用的倒斜線字符，就能讓易讀性向上提升一些，也可以減少在改字串內容時忘記要補上倒斜線的人爲疏失。雖然有點奇妙，但姑且就先記得有這一項選擇，看看有沒有那天會真的可以用上。

對於已經習慣使用輸入法來繕打各種全形括號的 CJK 使用者而言，或許更能善加利用這項機能吧。

在 2022 年 5 月釋出的 Perl 5.36.0 版中有不少舊的機能被徹底移除，但也多了不少新的機能。其中幾項令我注目的有：

• subroutine signature
• true, false, is_bool 及 builtin (實驗組)
• 一次抓出多個值的 for 迴圈 (實驗組)

subroutine signature

subroutine signature 在各語言中的意義都略有不同，但粗略地來說就是讓函式的參數列表成爲函式名稱的一部分。不過在 Perl 5.36.0 中尚沒有這麼先進，僅是把 @_ 這個代表參數列表的變數給藏了起來而已：

5.36.0 前的寫法：得多寫一行把 @_ 中各參數內容給拷貝出來：

          sub foo {
    my ($p, $q) = @_;
    ...
}
        

自 5.36.0 起，可改寫成如下。把參數直接列在函式名後面。在語法上，省去了使用 @_ 的一步。

          sub foo ($p, $q) {
    ...
}
        

這個語法自 5.20 版開始就被加入實驗組，幾番修改，現在總算是正式成爲核心語法的一部分了。

與此同時，如果在帶了參數列表的函式本文內又使用了 @_，就會讓 perl 發出警告。例如：

          use v5.36;

sub plus ($p, $q) {
    return $p + $_[1];
}

say plus(10, 1);
        

輸出：

          Use of @_ in array element with signatured subroutine is experimental at /tmp/x.pl line 4.
11
        

可看到 $_[1] 還是等於 $q，也還是可以用。但在執行時則會有一行警告訊息跑出來。

此外，還有個附帶的好處：在函式呼叫處，如果參數的個數與宣告處的參數個數不同，則會產生執行時期的錯誤，並且就地停止。比方說我們故意丟三個參數給 plus：

          use v5.36;

sub plus ($p, $q) {
    return $p + $q;
}

say "begin";
say plus(10, 1, 42);
say "end";
        

輸出：

          begin
Too many arguments for subroutine 'main::plus' (got 3; expected 2) at /tmp/x.pl line 8.
        

可看到這程式輸出只到 "begin" 爲止，沒有包含 plus 傳回值，也沒有包含 "end"。

其實我覺得最好是讓它在編譯時期就中止，不過目前這樣也還算不錯。只是在重構程式時要確保沒有少改任何一處，以免到部署上線之後才發現錯誤連連。

true, false, is_bool 及 builtin

一直以來 Perl 語言中都沒有對應到 true 與 false 這兩個值，現在有了。在程式中明確寫下來的 true 與 false，在函式呼叫傳值的過程中，都會被好好保留著。但，這兩個關鍵字尚不是直接就建在語言內，而是要自名爲 builtin 的這個個新核心模組引入。除了新關鍵字之外，所有測試用運算子都會回傳 true 或 false，而要明確判別 true/false 與其他值，則必須用 is_bool。

          use v5.36;
use builtin qw( true false is_bool );

my $p = (1 == 1);
say is_bool( $p ) ? "bool" : "not bool"; #=> "bool"
        

除了滿足新世代的「寫作習慣」之外，有特定值來代表 true / false 的好處就是能在將各變數轉換成 JSON 時，能夠清楚區分出 1、"1" 與 true 的不同，。

一次抓出多個值的 for 迴圈

這次在 for 迴圈的語法上加入了一次抓出多個值的新規則。讓人可以利用這種特性，使陣列內容兩兩一組或三三一組，做出簡單的資料結構。簡單的範例如下：

          use v5.36;

for my ($x, $y, $z) (1..11) {
    say "$x $y $z";
}
        

輸出：

          for my (...) is experimental at /tmp/x.pl line 4.
1 2 3
4 5 6
7 8 9
Use of uninitialized value in concatenation (.) or string at /tmp/x.pl line 5.
10 11 
        

可看到，在串列長度與迭代變數的個數不正好是倍數關係時，於最後一輪中，就會有幾個變數變成 undef。這設計還算合理。

感想

這次的新版出現了很多變更，稍微試用之後都覺得各設計還算合理。但似乎也有人覺得新語法的加入，漸漸地讓 Perl 語言失去了一些一致性，各語句之間變得越來越不像。不過多數變更都還是放在實驗組中的，起目的就是在於讓大家試用，找出癥結與痛點，加以改善，或是整組丟掉。

新的 builtin 核心模組的出現似乎是個不錯的方向，可把一些常用的，或不得不用的函式內部化，如果能逐漸充實到使人無需利用 CPAN 模組就能完成大部分簡單任務，那其實會是個很好的結果。

YAPC::Japan 研討會是日本這裡的 Perl 研討會的主幹，是 YAPC::Asia 的後繼。從名稱上看來就知道 JPA 它們把規模縮小了。這樣其實很好，至少可以朝精緻化的方向前進。這幾年下來一年一回也是都辦得不錯。

前一回實體的 YAPC::Japan 研討會是 2019 年年初在東京，當時我以靜態分析與與源碼修改建議機器人為主題給了一場 20 分鐘的日語演講。那之後本來 2020 年三月預計是要在京都辦實體聚會的，但是因為 covid19 的盛行與而在最後一刻而無期限延期，而 YAPC::Kyoto 大概就成為大家接下來最想去的 YAPC 了。

為了這回線上的 YAPC::Japan 研討會，主辦單位準備的「場地」大致上是這樣：

• 在議程前一天，觀眾會收到宅配。內容物是一箱禮物包跟一組烤全雞套餐，跟兩罐特製飲料，包括「YAPC 牌彈珠汽水」以及酒標是「perlbrew: Camel IPA」的啤酒。沒想到 perlbrew 真的變成酒標了。
• 雙軌議程，各自有 youtube 公開直播。影片網址分享到 SNS 上也無所謂，主辦單位有明確提到這一點。
• Discord 文字與聲音聊天空間。在演講直播當中，觀眾們可以利用 Discord 的聲音聊天室來立刻對演講反應，或跟「隔壁」的人立刻討論。如果講者本人也有參與聲音聊天室的話則可以聽到回應，但粗估資訊延遲約有 20 秒左右。
• 主辦單位以 Zoom 與講者連線，取得講者的所分享的螢幕畫面與 Webcam 影像，將兩影像源安到特定模板上後，做成直播影片。這個模板部分的主要目的，是將贊助商的名字與商標放在畫面一個角落輪播。
• 演講議程之外，另外有「幫忙學生線上解題」，以及「Perl 川柳大會」兩個活動。參與度似乎很熱烈。這川柳大會還有獎品。主辦單位最後有挑出五名佳作，贈予「技術書１万円分」。真是不錯啊。

在議程中的「下課時間」是 15 分鐘為單位，比起一般實體研討會似乎略微緊湊一些。在下課時間中，直播畫面就會開始播放贊助商提供的形象廣告影片。

LINE 與 DeNA 一直都是 YAPC::Japan 及 YAPC::Asia 的重量級贊助商，所以在議程中有特定的發言時段，事前送給觀眾的禮物與烤雞應該也是主要靠他們的贊助。而另外比較令我印象深刻的是，眾多贊助商中出現了必勝客披薩，他們有在閃電講中獲得五分鐘宣傳時段，而且講者講得還不錯，雖然單純就只是宣傳，不是與 Perl 或任何技術方面相關話題。但更妙的是，對於一部分報名者，他們提供了在指定時間送達的服務。因此在當日下午三點半前後可以在 Discord 與 Twitter 上同時看到超多人在說「Pizza 送來了」。

如果只是當觀眾的話，這樣的體驗，至少以「聽課」這個目的來說算是還不錯的。因為視線絕對不會被前面的人擋到，甚至如果漏聽了幾秒也還可以稍微倒帶回去補聽一下。但是完全沒辦法做出夠快的問答，至少在演講途中是無法模擬出「舉手問問題」的這個過程。Discord 的聲音聊天室大致上可以讓兩個人對話 N 個人聽也不會因延遲而感到怪怪的。似乎也足夠了。而且在講師講課時，聽眾也可以在 Discord 裡面討論，自由度（？）很高。

但反過來說，當講者的話，就要去習慣這所謂的給演講，其實只是自己對著自己的電腦螢幕講話，完全無法有任何方式去接受到從觀眾席傳來的任何反應。在 Zoom 畫面上，就只能看到同時連線在同一場會議中的工作人員數人。雖然一定程度上可以觀察他們的表情，但也只是聊勝於無。要在這種線上研討會給演講的話，好好地將自言自語的能力練好，似乎很重要。

「幫忙學生線上解題」的這個活動是有個出題者，出兩題不難的題目讓三位學生來解題，學生在解題的時候需要把螢幕分享在 Discord 頻道中讓觀眾看。如果觀眾看到學生卡關的話就可以提供口頭上的協助。雖然我不確定在這活動中三位學生的角色是怎麼決定出來的，但這似乎是個很有意思的群體活動。

這次我選擇給一場五分鐘長度的閃電講。講題是 aaa.pl，是 2018 年在 TPC::Glasgow 時以英語講過一次的題目，內容基本上算是半娛樂性質。當時沒什麼練習而講得有點結巴。這次以日語來講，而且由於「場地因素」，我無法知道聽眾是否看起來能聽懂我的破日語。為了不要出糗出的太超過，事前練習了六七次，沒想到每一次都遠超過五分鐘。還好有先練習與調整，不然實際上場時鐵定是要超時了。沒想到還得到了一個獎，或許有練習真的有差了，雖然是覺得有點意外的。但從聊天室與 twitter 上的訊息看來這次演講效果應該算是不錯吧。

依照慣例：這研討會活動在 SNS 上用 #yapcjapan 作為其標籤。在 twitter 上搜尋 #yapcjapan，就可獲得與其相關的各種訊息與事後感想。

拜讀了 Cloudflare 服務中斷報告，腦海浮現了對正規表示式去進行模糊測試的想法。針對此題目，我於 2019 年 Europe PerlCon 研討會上給了場五分鐘的閃電講：Fuzzing regexp (WIP)。

模糊測試的過程，大致上設想如下：

1. 對所指定的測試目標 r （正規表示式​）生成一測試用函式 f(x)。此函式的參數 x 為一個字串，回傳值為一個正整數，表示處理參數之字串所需要的步數。
2. 隨機產生許多長度為 1...n 的字串 x
3. 取所有 ( length(x), f(x) ​) ，以線性回歸判斷兩者關係是否為線性

雖然已經初步以 Regexp::Debugger 完成 refuzz​，但尚有兩點問題待解：

1. 隨機生成的字串 x 有很高的機率是不會與 r 匹配成功的，如果只生成那種很快就會匹配失敗的字串，f(x) 就會一直很小​。必須仔細依 r 的內容來撰寫字串產生器才能進行較有效率的測試。
2. Regexp::Debugger 所實做的是沒有經過任何最佳化過的 DFA​ 引擎，雖然有代表性，但可能與實際上各市面上常見的引擎有點出入

總之是個可以來慢慢研究的主題，日後若有更新再來追加補充。

pp comes with PAR::Packer, which is a tool for "compiling" a bunch of modules and codes and makes a single binary.

perldoc pp already contains a good amount of documentation one can refer to.

While it works with system perl, I found it even easier to first prepare a directory of local::lib, then just package that entire directory.

pp tries its best to determine the list of dependencies of the given program in various ways but none of those are guaranteed to be 100% accurate. As matter of fact that guarantee is impossible to make. This is partially due to the fact that a running program can load modules in ways that cannot be easily determined by reading the program source code, or in a relative hidden code path that cannot be easily captured.

That is a good amount of flexibility, but definitely a pricey one. Although, arguably it is also an issue brought by the tool (pp, perlcc, perl2exe, etc.). I guess that is because the dynamic nature is so convenient as long as all the installation are done right. Having a tool that is able to automically complie all dependencies together was not needed that much. It has definidently needed, that is why we have those tools now, but in the last mile of their completion, lies an undecidable problem.

So we will need to manually add those missing depedencies to pp command, which is fine only when the list is small. Since we wish to just pack all the declared dependencies together, we don't care that much even if that's going to make the result a little bigger than it has to be. If we can have the same build script that works everywhere, it is as happy as in Christmas. (An pure metaphoric experssion. Pesonally I feel nothing spceial in Dec 25.)

Anyway...... it turns out to be much easier to decide the dependency at installation time, since that's all well-declared and tools like cpm, or cpanm already does this perfectly. If we install dependencies in a self-contained directory, we could just archive the entire directory together with the program we are packing, and that should be good to go.

Let's say we cd into the source code of foo and we are trying to compile the program foo as a binary. The executable is at bin/foo, while its own moulders such as Foo.pm, Foo/Bar.pm are put under the conventional directory lib.

Given that, this script should produce foo as a single binary that as if all dependencies are "statically-linked" inside:

          #!/bin/bash

# Prepare local/ 
cpanm -L local -q --installdeps .
# or: cpm install

perlversion=$(perl -MConfig -e 'print $Config{version}')
pp -B \
    -I ./local/lib/perl5 \
    -a "./local/lib/perl5/;$perlversion/" \
    -a lib \
    -o foo \
    bin/foo
        

Alas, this is almost perfect -- except modules in corelist might still be missing. They won't be inside local/ and if they are somehow not discovered by pp then they'll be missing in the end result. We won't know this until we manually test the result foo thoroughly. Basically we should always add a bunch of -M flags in the build script instead of assuming pp would do the right thing.

For example, like so, when all of Getopt::Long, JSON::PP, and Sys::Hostname are required.

          pp -B \
    -M Getopt::Long:: \
    -M JSON::PP:: \
    -M Sys::Hostname:: \
    -I local/lib/perl5 \
    -a "./local/lib/perl5/;$perlversion/" \
    -a lib \
    -o foo \
    bin/foo
        

A rather tedious modification as the list of dependent modules now exists in two places in the repo. Surely there is some way to refactor this.

I've verified the following script build-minicpan.sh that can download the tarball of CPAN::Mini and build a working minicpan out of it:

          #!/bin/bash
set -e

curl --silent -O https://cpan.metacpan.org/authors/id/R/RJ/RJBS/CPAN-Mini-1.111016.tar.gz

tar -xzf CPAN-Mini-1.111016.tar.gz

cd CPAN-Mini-1.111016

cpanm -n -q -L local --installdeps .

perlversion=$(perl -MConfig -e 'print $Config{version}')

pp -B \
   -M Getopt::Long:: \
   -I ./local/lib/perl5 \
   -a "./local/lib/perl5/;$perlversion/" \
   -a lib \
   -o ../minicpan \
   bin/minicpan

echo "DONE: minicpan"
        

To me this seems to be an area worth exploring... I've been experimenting the automation of this in a side-project: pau, which is a collection of shell functions that can install app to their own self-contained directory and expose just the program itself. Very similar to what pipx does. The support of pp was added not long ago but still, there is no good way to figure out all the missing modules and automatically add them as -M arguments.

Maybe as a lazy solution, we should just always produce a heavy-pack that includes the whole core lib directory (usually $INC[-1]) regardless whether any of them are used.

Maybe.

Perl::Critic::TooMuchCode is a set of policy addons that generally checks for dead code or redundant code.

It's just about a week after the release of 0.17 and after asynchronously exchanged some thoughts with @oalders and @ferki (Issue #25), I decide to make a follow-up release shortly.

In version 0.17 we updated the policy ProhibitDuplicateLiteral to include a new config parameter whitelist to replace the old parameter whitelist_number. In version 0.18 they are both removed. The replacement for them is the parameter allowlist.

So now if we really need to write number 42 and "forty two" literally many times, we list them in .perlcriticrc:

          [TooMuchCode::ProhibitDuplicateLiteral]
allowlist = "forty two" 42
        

The name "allowlist" was previously suggested by @ferki already and I amended to match existing convention of using "whitelist". Now I decide that such convention should be changed (See PR #28). It's a better naming choice in the sense that it direct and explicit, perhaps until the day the word "allow" lost its current meaning.

The other improvement is to address Issue 18 (thanks to @oalders again.), in which assignment of imported symbols to @EXPORT or @EXPORT_OK as correctly counted as using those symbol by the policy ProhibitUnusedImport.

There have not counted because it is also a correct thing to do. Considering we have three symbols in place: foo, $bar, and @baz, and an assignment like this:

          my @stuff = qw(foo $bar @baz);
        

Although those symbols appears in the statement literally, evaluating that statement does not depends on the evaluation of those symbols because they are all quoted inside of qw(). @stuff is evaluated to 3 strings: 'foo', '$bar', and '@baz', which has nothing to do with foo (bareword, perhaps a subroutine name), $bar, and '@baz'.

However, if the LHS array variable is either @EXPORT or @EXPORT_OK, the assignment has different meaning:

          our @EXPORT = qw(foo $bar @baz);
our @EXPORT_OK = qw(@baz);
        

@EXPORT itself is still assigned with just 3 strings, but eventually when the current module is imported (use-ed or require-ed) by a foreign piece of code, those 3 strings refer some content in the symbol table and they might be used remotely.

Well, whether foo is really used remotely is probably unknown-able. It should be sufficient to just consider the case of assignments involving @EXPORT and @EXPORT_OK.

I'm guessing that there are probably more special cases yet to be discovered regarding those special variables in perlvar, or however famous module X defined its own sub-language for us to cope with.