[Perl 6]Perl 5 to 6 中译版 ( 完整 )

iakuf

"Perl 5 to 6" Lesson 06 - Contexts 上下文

概要

1. my @a = <a b c>;
   
2. my $x = @a;
   
3. say $x[2];          # c
   
4. say (~2).WHAT;      # (Str)
   
5. say +@a;            # 3
   
6. if @a < 10 { say "short array"; }
   

复制代码

描述

当你写了一些如下的东西

1. $x = @a

复制代码

在 Perl 5 中 $x 包含的信息会比 @a 少很多 - 它包含只有 @a 中元素的个数 ( 因为列表环境 ). 要保存所有的信息, 你只能明确的指出它是一个引用: $x = \@a.

在 Perl 6 中是反过来的: 默认你不会丢失任何东西, 标量会存储整个数组. 之所以能这样, 是因为有一个 item 的通用上下文 ( 在 Perl 5 中叫 scalar ) 和其它更加特定的象数字, 整型和字符上下文. 空和列表上下文保持不变.

你可以强制上下文环境, 通过下面的语法

1. 
   
2. 语法         上下文
   
3. 
   
4. ~stuff       String
   
5. ?stuff       Bool (logical)
   
6. +stuff       Numeric
   
7. -stuff       Numeric (also negates)
   
8. $( stuff )   Generic item context
   
9. @( stuff )   List context
   
10. %( stuff )   Hash context
    
11. stuff.tree  Tree context

复制代码

Tree Context

在 Perl 6 的初期, Tree 上下文在众多的 builtins 里有两个版本存在, 一个用于返回普通的列表 flat list, 一个返回 a list of arrays 数组列表 ( 象是数组的数组 ).

现在是通过返回 Parcel 的对象列表, 通过这个 Parcel 对象会根据上下文来返回可能会和可能不会拉平数组.

第一种情况, 比如我们使用中缀操作 Z ( 它是 zip 操作的简写 ) 操作符, 交错的从这二个列表中取元素:

1. my @a = <a b c> Z <1 2 3>;
   
2. say @a.join;                # a1b2c3

复制代码

这所做的事情是, 第一个语句的右边返回 ('a', 1), ('b', 2), ('c', 3), 并赋值给一个数组, 它提供列表上下文, 然后接下操作会拉平内部的元素变成整个 @a 的元素成一个普通列表.

我们来看另一种情况, 这时是 tree 上下文

1. my @t = (<a b c> Z <1 2 3>).tree;

复制代码

这个 @t 现在包含三对元素, 整个数组都没有拉平到 @t 中, 还是保持着自己的结构, 然后才存入 @t 这时会是一个 Parcel 对象的数组列表.

1. for @t -> @inner {
   
2.     say "first: @inner[0]  second: @inner[1]"
   
3. }

复制代码

会输出:

1. first: a  second: 1
   
2. first: b  second: 2
   
3. first: c  second: 3

复制代码

动机

在设计 Perl 6 的上下文的时候, 这些开发人员选择了不要过在决定一个数据结构在不同上下文中的返回值. 例如, 一个列表在标量上下文中应该返回什么 ? 如果返回一个列表的引用, 好处就是能保留所有的信息, 但是坏处就是在需要做数字比较的时候用处不大. 如果返回一个字符串呢, 在调试阶段就会非常有用. 所以舍弃哪种都有相应的不好的地方。

大多的时候, 你根本不要做这样的选择 - 它都会返回合理的值. 不需要你选择怎么样返回.

对于一些事情, 象 Match 对象, 这种不同的上下文也很大程度上提升了实用性和美感.
另请参阅

http://perlcabal.org/syn/S02.html#Context http://perlgeek.de/blog-en/perl- ... ls-and-context.html

iakuf

"Perl 5 to 6" Lesson 07 - Regexes 正则表达式 (也叫 "rules")

概要

1. grammar URL {
   
2.     token TOP {
   
3.         <schema> '://'
   
4.         [<ip> | <hostname> ]
   
5.         [ ':' <port>]?
   
6.         '/' <path>?
   
7.     }
   
8.     token byte {
   
9.         (\d**1..3) <? $0 < 256 \}>
   
10.     }
    
11.     token ip {
    
12.         <byte> [\. <byte> ] ** 3
    
13.     }
    
14.     token schema {
    
15.         \w+
    
16.     }
    
17.     token hostname {
    
18.         (\w+) ( \. \w+ )\*
    
19.     }
    
20.     token port {
    
21.         \d+
    
22.     }
    
23.     token path {
    
24.         <[ a..z A..Z 0..9 \-_.!~\*'():@&amp;=+$,/ ]>+
    
25.     }
    
26. }
    
27. 
    
28. my $match = URL.parse('http://perl6.org/documentation/');
    
29. say $match<hostname>;       # perl6.org

复制代码

描述

译者注: 不同于传统的正则表达式, Perl 6 不需要你记住的元字符的列表. 它通过一个简单的规则进行分类字符. 比如扩展的元语法 metasyntax 形式是 ( <...> ) 这样包含着字符. 比如 <.ws> 是尖括号包着 .ws 表示匹配空格. 其中的 . 表示不要捕获到正则的变量名 $ 中.

正则表达式已经在 Perl 6 中改良和革新, 这是重大改进之一. 我们不叫它 regular expressions 了. 因为它比起 Perl 5 更加不正规了.

正则表达式有三个大的更改和改进

语法更加干净

许多小变化使得规则更加容易编写. 例如, dot . 在匹配任何字符, 旧的 Perl 5 中的语义是要除去换行. 现在你可以使用 \N 来实现匹配零个或者多个非换行符.

修饰符现在是放在正则表达式的起始位置, 并且修改了非捕获组变成是 [...], 这比起旧的 (?:...) 更加容易读取和写.

嵌套捕获和 match 对象

在 Perl 5 中, 正则 (a(b))(c) 会给 ab 存到 $1, b 会存到 $2 和 c 存到 $3. 这种情况现在改变, 现在 $0 (枚举从零开始)包含 ab, $0[0] or $/[0][0] 包含 b, $1 存着 c. 所以括号中的每个嵌套级别反映在结果匹配对象的一个新的嵌套级别.

所有匹配变量是别名为 $/，也就是所谓的 Match object, 它实际上是一个包含了完整的匹配树型结构的对象。

命名的正则和 grammars

在 Perl 6 中开始, 你可以给你所写的正则表达式一个名字, 就象在子函数和方法中一样有自己的名字. 通过 <name> 这种方式来在其它地方重新使用这个. 你可以给多个正则表达式做成 grammars, 这就象类和支持继承和组合.

这些改变使得 Perl 6 的正则表达式和 grammars 比起 Perl 5 更加容易维护和编写.

这些变化的东西比较深, 这个文章中, 我们只能见到表面的东西.

语法更加干净

字母字符 ( 如下划线, 数字和所有 Unicode 字符 [a-zA-Z0-9_] ) 是根据字面内容来匹配, 也就是指, 它是什么就是什么, 当使用反斜杠转义这些字符时就会具有特殊的意义 ( 这是元语法 metasyntactic ).

对于所有的其它字符 ( 非 [a-zA-Z0-9_] ) 是反过来的 - 除非它转义(也就是说特殊字符 * 就是有特殊含义的，如果你想匹配一个 "星号"，那就要用 "*").

1. 
   
2. 字面意思       元语法
   
3. a  b  1  2      \a \b \1 \2     # 普通字符 [a-zA-Z0-9_]
   
4. \* \: \. \?     *  :  .  ?      # 其它字符 非 [a-zA-Z0-9_]

复制代码

并不是全部反斜杠转义的字符都是元语法 metasyntactic tokens 都有特别的含义. 除了 \a \b \1 \2 外, 可能其它的使用反斜杠转义的并没有确切的定义, 这时这些是非法的.

在正则表达式中还有另一种方法来转义字符串: 通过引号.

1. m/'a literal text: $#@!!'/

复制代码

在 Perl 6 中这改变了 . 的语义, 这个前面提过, 同时改变的还有 [...] 现在用于构建非捕获组. 字符类是　<[...]>　和非字符类<-[...]>. ^　和　$　总是匹配开始和结束的字符串. 匹配行的开始和结束是使用　^^　和　$$.

这意味着原来的 /s 和/m 修饰都没有了. 修饰符现在是在正则表达式中, 是在一开始的位置来给出:

1. if "abc" ~~ m:i/B/ {
   
2.     say "Match";
   
3. }

复制代码

... 这又是使用的 colon pair 符号. 你可以使用起来象子函数给个命名参数一样.

修饰符有一个短的和长的形式. 现在老 /x 修饰符是默认的, 即空格会被忽略.

1. 简写    长的写法            意义
   
2. -------------------------------
   
3. :i      :ignorecase     忽略大小写 ( 旧的 /i )
   
4. :m      :ignoremark     忽略一些标记 ( 重音, 分音符号等 )
   
5. :g      :global         全局替换 ( 旧的 /g )
   
6. :s      :sigspace       正则表达式匹配所有空格
   
7.                         (可选) 空格
   
8. :P5     :Perl5          退回到 Perl 5 所兼容正则表达式语法
   
9. :4x     :x(4)           Match four times (works for other numbers as well)
   
10. :3rd    :nth(3)         Third match
    
11. :ov     :overlap        很象 :g, 但这会考虑重叠的匹配
    
12. :ex     :exhaustive     Match in all possible ways
    
13.         :ratchet        不回溯

复制代码

这的 :sigspace 需要花些时间来解释. 它通过使用了 <.ws> 的有名字的正则替换了模式中的空格 ( 这是调用 rule ws 并不保存捕获的结果 ).　你可以覆盖该规则.

的规则默认会匹配二个单词中间所包含的一个或者多个空格. 如果不是单词之间就是匹配零个或者多个空格.

Match 对象

每个匹配会生成一个叫 match 对象的东西, 会给这些匹配到的内容存储到指定的变量 $/ 中.　它是非常有用的. 如果匹配成功并且在布尔上下文中, 它返回 Bool::True. 在字符上下文会返回匹配到的字符, 作为一个列表时会返回其中包含的捕获位置, 作为哈希使用时它包含命名捕获. 这个对象有 .from 和 .to 方法, 会返回包含首先的和最后的字符位置上找到的内容.

1. if 'abcdefg' ~~ m/(.(.)) (e | bla ) $<foo> = (.) / {
   
2.     say $/[0][0];           # d
   
3.     say $/[0];              # cd
   
4.     say $/[1];              # e
   
5.     say $/<foo>             # f
   
6. }

复制代码

这的 $0, $1 只是 $/[0], $/[1] 的别名. 同样 $/<x> 和 $/{'x'} 也只是 $<x> 的别名.

注意, 任何你通过 $/[...] 和 $/{...} 访问的都是 match 对象( 或者是 match 对象的列表 ). 这可以让你通过 rules 创建真实的解析树.

命名正则和 Grammars

正则表达式可以使用旧的风格 m/.../, 或者可以使用名字来给他们声明成象子函数和方法一样.

1. regex a { ... }
   
2. token b { ... }
   
3. rule  c { ... }

复制代码

所不同的是 token 隐含了 :ratchet 修饰符 ( 这意味着没有回溯, 象 (?> ... ) 组包含各自的部分 ), 这个 rule 隐含了 :ratchet 和 :sigspace 二个修饰符.

要调用这些规则 ( 我们会要调用的全部的这些规则, 通过关键字声明后会相互独立 ) 只要使用尖括号中加名称: <a> 就可以使用. 这隐含地规则的字符串会放到的当前位置, 存储匹配到的结果到 $/<a> 的对象中, 也就是说, 它是也是一个命名捕获. 你也可以使用 <.a> 来调用不做命名捕获的匹配 ( 不同处在于加了前缀点 ).

grammar 是一系列规则的组合, 这很象对象中的类 ( 看　SYNOPSIS　中的例子). Grammars 可以继承, 重写规则等.

1. grammar URL::HTTP is URL {
   
2.     token schema { 'http' }
   
3. }

复制代码

动机

Perl 5 的正则表达式常常不太可读, grammars 这个东西是鼓励你把一个大的正则表达式表示成为更可读的, 短的片段. 命名捕获使规则更加能实现自我文档, 而且很多东西比起以前现在更加一致.

最后, grammars 是如此强大, 你可以用它分析了解每一种编程语言, 包括 Perl6 本身. 这使得 Perl 6 的语法比起 Perl 5 更易于维护和修改.

另请参阅

http://perlcabal.org/syn/S05.html

http://perlgeek.de/en/article/mutable-grammar-for-perl-6

http://perlgeek.de/en/article/longest-token-matching

rongchaogao

继续追！

104359176

如何让 iakuf 喜欢上 newlisp, 把 newlisp 的文档给翻译下呢？

mcshell

支持~~感觉6比5的语法更加让别人看不懂了,,不过也让开发者更为"偷懒"了~~

iakuf

"Perl 5 to 6" Lesson 07 - Junctions

概要

1. my $x = 4;
   
2. if $x == 3|4 {
   
3.     say '$x is either 3 or 4'
   
4. }
   
5. say ((2|3|4)+7).perl        # (9|10|11)

复制代码

描述

Junctions 是叠加的一堆无序的值. 操作 junctions 的时候是对各自己的元素分别执行 ( 甚至是并行的 ), 并且结果组装成原来相同的类型.

在 junction 类型唯一的不同点在于计算布尔上下文时. junction 的中有类型 any, all, one 和 none, 不同的中缀运算符表示不同的 junction 类型.

1. 类型   中缀运算符
   
2. any     |
   
3. one     ^
   
4. all     &
   

复制代码

1 | 2 | 3 等同于 any(1..3).

1. my Junction $weekday = any <Monday Tuesday Wednesday
   
2.                             Thursday Friday Saturday Sunday>
   
3. if $day eq $weekday {
   
4.     say "See you on $day";
   
5. }

复制代码

在这个例子中 eq 的这个操作因为 Junction 是 any 所以会调用每个元素象 $day, 'Monday', $day, 'Tuesday' 等等. 并将结果放入 any-junction 中来. 在运行的过程中只要结果被确认了 ( 在这个例子中, 只要有任意一个比较返回 '真' ) 它可以会中止其他比较的执行.

这不但对操作符有效, 对子函数也行:

1. if 2 == sqrt(4 | 9 | 16) {
   
2.     say "YaY";
   
3. }

复制代码

为了做到这一点, junction 是放在了正常的类型层次结构之外的:

1.                   Mu
   
2.                 /    \\
   
3.                /      \\
   
4.              Any     Junction
   
5.            /  |  \\
   
6.         All other types

复制代码

如果你想写一个函数使用这个 junction 并且不 autothread　这个子函数, 你可以声明这些的参数是 Mu 或者是 Junction.

1. sub dump_yaml(Junction $stuff) \{
   
2.     # we hope that YAML can represent junctions ;-)
   
3.     ....
   
4. }

复制代码

提醒一句: Junctions 有时的表现会和你的直觉相反. 如果是非 junction 类型的时候 $a != $b 和 !($a == $b) 总是相同的结果. 如果这些变量中有一个是 junction 类型时, 这个结果就不一样了.

1. my Junction $b = 3 | 2;
   
2. my $a = 2;
   
3. say "Yes" if   $a != $b ;       # Yes
   
4. say "Yes" if !($a == $b);       # no output

复制代码

2 != 3 是为真, 这 $a != 2|3 也是为真. 在其它的时候象 $a == $b 比较会返回布尔值 ( True ), 然后在取反为 False.

动机

Perl 的目标是要接近自然语言, 自然语言中你常常会这样讲 "如果这个结果这样或者那样" 而不会讲 "如果这个结果是这样或者这个结果是那样". 很多编程语言都只能使用后者, 感觉有点奇怪. 所以还是 Perl 6 比较好.

这个东西也让你做很多事情容易多了, 不然要使用循环实现同样的功能需要写很多比较.

例如, 有个数组全部都是数字的, 你想知道如果全部的是不是都是非负数, 在 Perl 5 中, 你可能会写成下面这样:

1. # Perl 5 code:
   
2. my @items = get_data();
   
3. my $all_non_neg = 1;
   
4. for (@items){
   
5.     if ($_ < 0) {
   
6.         $all_non_neg = 0;
   
7.         last;
   
8.     }
   
9. }
   
10. if ($all_non_neg) { ... }

复制代码

如果你知道 Perl 5 中的这个模块, List::MoreUtils 你可能会写成:

1. use List::MoreUtils qw(all);
   
2. my @items = get_data;
   
3. if (all { $_ >= 0 } @items) { ...  }

复制代码

在 Perl 6 中你只需要写成:

1. my @items = get_data();
   
2. if all(@items) >= 0 { ... }

复制代码

A Word of Warning

很多人知道这个 junctions 非常高兴, 都会大量尝试使用这个.

但要知道 Junctions 并不是一个 sets ( 集合 ); 所以你没法从 junction 中提取元素, 你这样做就错了, 所以你想要这样就要使用 Set 替代.

It is a good idea to use junctions as smart conditions, but trying to build a solver for equations based on the junction autothreading rules is on over-extortion and usually results in frustration.

另请参阅

http://perlcabal.org/syn/S03.html#Junctive_operators

iakuf

"Perl 5 to 6" Lesson 09 - 比较和匹配

概要

1. "ab"    eq      "ab"    True
   
2. "1.0"   eq      "1"     False
   
3. "a"     ==      "b"     failure, because "a" isn't numeric
   
4. "1"     ==      1.0     True
   
5. 1       ===     1       True
   
6. [1, 2]  ===     [1, 2]  False
   
7. $x = [1, 2];
   
8. $x      ===     $x      True
   
9. $x      eqv     $x      True
   
10. [1, 2]  eqv     [1, 2]  True
    
11. 1.0     eqv     1       False
    
12. 
    
13. 'abc'   ~~      m/a/    Match object, True in boolean context
    
14. 'abc'   ~~      Str     True
    
15. 'abc'   ~~      Int     False
    
16. Str     ~~      Any     True
    
17. Str     ~~      Num     False
    
18. 1       ~~      0..4    True
    
19. -3      ~~      0..4    False

复制代码

描述

Perl 6 仍有字符串比较操作符 ( eq, lt, gt, le, ge, ne; cmp 现在叫 leg ) 用于比较字符上下文件的操作. 同样 Perl 5 中的所有数值运算符还是存在.

由于对象是 blessed 的引用, 需要新的方式来进行比较 === 只有当值都相同的时候才返回真. 对于数字和字符串是正常的相等性测试, 其它的东西都是比较二个变量是否引用同一个东西( 象 C++ 中的内存地址比较 );

eqv 的测试是比较二个东西是不是等价的, 比较他们需要它们有相同的类型并也有相同的值. 在容器类型象数组和哈希, 使用 eqv 来进行比较. 二个结构相同的数组结构是不是等价.

智能匹配

perl 6 有一个通用比较符, 叫 "智能匹配" 操作符, 拼写成 ~~. 它是不对称对比的, 一般右边的操作数的类型决定使用哪种比较. 在新版本的 Perl 5 中也存在.

对于数字和字符串是进行简单的相等比较. 智能匹配对于类型和对象是检查类型是否一致. 智能匹配对一个正则表达式是检查是否匹配正则. 如果一个标量会对比 Range 是否在这个范围内能查找到.

还有其它更加高级的匹配形式: 比如你可以检查一个参数列表 ( Capture ) 非常合适子函数参数或者文件测试操作.

你只需要记住, 任何 "这个 $x 是否合适 $y?" 这种问题都可以使用 Perl 6 的智能匹配.

另请参阅

[http://perlcabal.org/syn/S03.html#Smart_matching]

xudongxu27

Mark!!!! 谢谢楼主分享！

iakuf

"Perl 5 to 6" Lesson 10 - 容器和值

Synopsis

1. my ($x, $y);
   
2. $x := $y;
   
3. $y = 4;
   
4. say $x;             # 4
   
5. if $x =:= $y {
   
6.     say '$x and $y are different names for the same thing'
   
7. }

复制代码

描述

Perl 6 区分不同的容器和值能存到各自的容器中.

标量变量是一个容器, 并能有像类型的限制, 访问限制 ( 例如, 它可以是只读的 ) 之类的一些属性, 最后它可以被关联到其他容器.

放入值到容器, 叫做分配 assignment. 给两个容器做成别名被称为 '绑定'.

1. my @a = 1, 2, 3;
   
2. my Int $x = 4;
   
3. @a[0] := $x;     # 绑定: 现在 @a[0] 和 $x 是相同的值
   
4. @a[0] = 'Foo';   # 错误 'Type check failed'

复制代码

类型 Int 和 Str 的类型是不能改变的, 所以这些对象不能被改变, 但你可以修改这些东西的值 ( 在容器中的值 ):

1. my $a = 1;
   
2. $a = 2;     # no surprise here

复制代码

绑定也可以在编译的时候就完成, 我们需要使用 ::= 操作符就可以了.

你可以通过 =:= 的操作符来比较二个绑定在一起的东西.

动机

在子函数中的 Exporting 导出和 importing 导入类型和值都是通过别名的方式. 这用于替代 Perl 5 中难以理解的 typeglob 的语法, Perl 6 提供的这个简单多了.

另请参阅

[http://perlcabal.org/syn/S03.html#Item_assignment_precedence]

iakuf

"Perl 5 to 6" Lesson 11 - 进化了以后的 Perl 5 中的操作符

概要

1. # 位运算符
   
2. 5   +| 3;       # 7
   
3. 5   +^ 3;       # 6
   
4. 5   +& 3;       # 1
   
5. "b" ~| "d";     # 'f'
   
6. 
   
7. # 字符串连接
   
8. 'a' ~ 'b';      # 'ab'
   
9. 
   
10. # 文件测试
    
11. if '/etc/passwd'.path ~~ :e { say "exists" }
    
12. 
    
13. # 重复
    
14. 'a' x 3;        # 'aaa'
    
15. 'a' xx 3;       # 'a', 'a', 'a'
    
16. 
    
17. # 三元, 条件运算
    
18. my ($a, $b) = 2, 2;
    
19. say $a == $b ?? 2 * $a !! $b - $a;
    
20. 
    
21. # chained comparisons
    
22. my $angle = 1.41;
    
23. if 0 <= $angle < 2 * pi { ... }

复制代码

描述

所有的数值运算符 (+, -, /, *, **, %) 在 Perl 6 中保持不变.

由于 |, ^ 和 & 现在 junctions 在使用, 所以位算符改变了语法. 它们现在包含一个上下文前缀, 所以象 +| 是逐位的运算基于数字上下文. ~^ 是对字符串上下文的异或. 位移操作也有相同的上下文前缀.

字符串连接现在是使用的 ~, 因为 . 现在被用于方法调用了.

文件测试, 现在是使用 Pair ( 字符:功能 ) 符号, 在 Perl 5 中的 -e 现在是 :e. 如果你不是想对 $_ 进行检查操作, 你可以使用 $filename.path ~~ :e 的方式来指定路径.

这个重复操作 x 现在分开成二个操作符: x 是重复字符串, xx 是重复的列表.

三元运算符, 原来的 $condition ? $true : $false, 现在需要写成 $condition ?? $true !! $false.

比较操作符现在可以做成一串的链, 所以你可以根据你的意思, 写成象 $a < $b < $c.

动机

这些操作符的改变, 主要是为了写出更加好读好看的代码, 比如给最常使用的东西使用比较短的名字 ( 比如 . 现在用于方法调用 ) 和对于比较少使用的操作使用比较长的名字 ( 比如 ~& 对于子符串进行位操作 );

这些操作符的改变之类都是为了使语言更加象自然语言一样.

另请参阅

[http://perlcabal.org/syn/S03.html#Changes_to_Perl_5_operators]