is Any
Cool，也称为Convenient OO Loop，是一个基类，由许多内置类使用，其实例可以有意义地强制转换为字符串和数字。例如，Array 可用于数学运算中，其中其数字表示形式是它包含的元素数量。同时，它可以连接到字符串中，其中其字符串表示形式是其所有元素由空格连接而成。因为Array是Cool，所以适当的强制转换会自动发生。
Cool 中的方法将调用者强制转换为更具体的类型，然后在该类型上调用相同的方法。例如，Int 和 Str 都继承自 Cool，并且在 Int 上调用方法 substr 会先将整数转换为 Str。
123.substr(1, 1); # '2', same as 123.Str.substr(1, 1)
几个内置类型继承自 Cool。请参阅下面的 类型图 以获取快照。
下表总结了 Cool 提供的方法以及它们强制转换到的类型
| 方法 | 强制转换类型 |
|---|---|
| abs | Numeric |
| conj | Numeric |
| sqrt | Numeric |
| sign | Real |
| rand | Numeric |
| sin | Numeric |
| asin | Numeric |
| cos | Numeric |
| acos | Numeric |
| tan | Numeric |
| tanh | Numeric |
| atan | Numeric |
| atan2 | Numeric |
| atanh | Numeric |
| sec | Numeric |
| asec | Numeric |
| cosec | Numeric |
| acosec | Numeric |
| cotan | Numeric |
| cotanh | Numeric |
| acotan | Numeric |
| sinh | Numeric |
| asinh | Numeric |
| cosh | Numeric |
| acosh | Numeric |
| sech | Numeric |
| asech | Numeric |
| cosech | Numeric |
| acosech | Numeric |
| acotanh | Numeric |
| cis | Numeric |
| log | Numeric |
| exp | Numeric |
| roots | Numeric |
| log10 | Numeric |
| log2 | Numeric |
| unpolar | Numeric |
| round | Numeric |
| floor | Numeric |
| ceiling | Numeric |
| truncate | Numeric |
| chr | Int |
| ord | Str |
| chars | Str |
| fmt | Str |
| uniname | Str |
| uninames | Seq |
| unival | Str |
| univals | Str |
| uniprop | Str |
| unimatch | Str |
| uc | Str |
| lc | Str |
| fc | Str |
| tc | Str |
| tclc | Str |
| flip | Str |
| trans | Str |
| contains | Str |
| index | Str |
| rindex | Str |
| ords | Str |
| split | Str |
| match | Str |
| comb | Str |
| subst | Str |
| sprintf | Str |
| printf | Str |
| samecase | Str |
| trim | Str |
| trim-leading | Str |
| trim-trailing | Str |
| EVAL | Str |
| chomp | Str |
| chop | Str |
| codes | Str |
| Complex | Numeric |
| FatRat | Numeric |
| Int | Numeric |
| Num | Numeric |
| Rat | Numeric |
| Real | Numeric |
| UInt | Numeric |
方法§
例程 abs§
sub abs(Numeric() )method abs()
将调用者（或在子形式中，参数）强制转换为 Numeric 并返回绝对值（即非负数）。
say (-2).abs; # OUTPUT: «2»say abs "6+8i"; # OUTPUT: «10»
方法 conj§
method conj()
将调用者强制转换为 Numeric 并返回 Complex 共轭（即虚部符号取反的数）。
say (1+2i).conj; # OUTPUT: «1-2i»
方法 EVAL§
method EVAL(*)
它使用调用者作为第一个参数 $code 调用 子例程形式，传递命名参数（如果有）。
例程 sqrt§
sub sqrt(Numeric(Cool) )method sqrt()
将调用者强制转换为 Numeric（或在子形式中，参数）并返回平方根，即乘以自身产生原始数的数。
say 4.sqrt; # OUTPUT: «2»say sqrt(2); # OUTPUT: «1.4142135623731»
对于负数参数返回NaN。从 6.e 语言版本开始（Rakudo 编译器 2023.02+ 中存在早期实现），将为负数参数返回一个 Complex 值。
say sqrt(-1); # OUTPUT: «0+1i»
方法 sign§
method sign()
将调用者强制转换为 Real 并返回其符号，即，如果该数字为 0 则返回 0，如果为正值则返回 1，如果为负值则返回 -1。
say 6.sign; # OUTPUT: «1»say (-6).sign; # OUTPUT: «-1»say "0".sign; # OUTPUT: «0»
方法 rand§
method rand()
将调用者强制转换为 Num 并返回介于零和该数字之间的伪随机值。
say 1e5.rand; # OUTPUT: «33128.495184283»
例程 sin§
sub sin(Numeric(Cool))method sin()
将调用者（或在子形式中，参数）强制转换为 Numeric，将其解释为弧度，返回其 正弦。
say sin(0); # OUTPUT: «0»say sin(pi/4); # OUTPUT: «0.707106781186547»say sin(pi/2); # OUTPUT: «1»
请注意，Raku 不是计算机代数系统，因此 sin(pi) 通常不会产生精确的 0，而是一个非常小的 Num。
例程 asin§
sub asin(Numeric(Cool))method asin()
将调用者（或在子形式中，参数）强制转换为 Numeric，并返回其 反正弦（以弧度为单位）。
say 0.1.asin; # OUTPUT: «0.10016742116156»say asin(0.1); # OUTPUT: «0.10016742116156»
例程 cos§
sub cos(Numeric(Cool))method cos()
将调用者（或在子形式中，参数）强制转换为 Numeric，将其解释为弧度，返回其 余弦。
say 0.cos; # OUTPUT: «1»say pi.cos; # OUTPUT: «-1»say cos(pi/2); # OUTPUT: «6.12323399573677e-17»
例程 acos§
sub acos(Numeric(Cool))method acos()
将调用者（或在子形式中，参数）强制转换为 Numeric，并返回其 反余弦（以弧度为单位）。
say 1.acos; # OUTPUT: «0»say acos(-1); # OUTPUT: «3.14159265358979»
例程 tan§
sub tan(Numeric(Cool))method tan()
将调用者（或在子形式中，参数）强制转换为 Numeric，将其解释为弧度，返回其 正切。
say tan(3); # OUTPUT: «-0.142546543074278»say 3.tan; # OUTPUT: «-0.142546543074278»
例程 atan§
sub atan(Numeric(Cool))method atan()
将调用者（或在子形式中，参数）强制转换为 Numeric，并返回其 反正切（以弧度为单位）。
say atan(3); # OUTPUT: «1.24904577239825»say 3.atan; # OUTPUT: «1.24904577239825»
例程 atan2§
sub atan2(, = 1e0)method atan2( = 1e0)
该子例程通常应使用两个参数编写，以提高清晰度，就像在其他语言和数学文本中看到的那样，但单参数形式可用；其结果将始终与 atan 的结果相匹配。
say atan2 3, 1; # OUTPUT: «1.2490457723982544»say atan2 3; # OUTPUT: «1.2490457723982544»say atan2 ⅔, ⅓; # OUTPUT: «1.1071487177940904»
该方法将自身及其单个参数强制转换为 Numeric，使用它们来计算具有两个参数的 反正切（以弧度为单位）。
say 3.atan2; # OUTPUT: «1.24904577239825»say ⅔.atan2(⅓); # OUTPUT: «1.1071487177940904»
方法或子例程中的 $x 参数默认为 1，因此，在两个单参数情况下，函数将返回 x 轴与从原点到点 (3, 1) 的向量的弧度角 θ。
例程 sec§
sub sec(Numeric(Cool))method sec()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，将其解释为弧度，返回其 正割，即其余弦的倒数。
say 45.sec; # OUTPUT: «1.90359440740442»say sec(45); # OUTPUT: «1.90359440740442»
例程 asec§
sub asec(Numeric(Cool))method asec()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其弧度形式的 反正割。
say 1.asec; # OUTPUT: «0»say sqrt(2).asec; # OUTPUT: «0.785398163397448»
例程 cosec§
sub cosec(Numeric(Cool))method cosec()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，将其解释为弧度，返回其 余割，即其正弦的倒数。
say 0.45.cosec; # OUTPUT: «2.29903273150897»say cosec(0.45); # OUTPUT: «2.29903273150897»
例程 acosec§
sub acosec(Numeric(Cool))method acosec()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其弧度形式的 反正割。
say 45.acosec; # OUTPUT: «0.0222240516182672»say acosec(45) # OUTPUT: «0.0222240516182672»
例程 cotan§
sub cotan(Numeric(Cool))method cotan()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，将其解释为弧度，返回其 余切，即其正切的倒数。
say 45.cotan; # OUTPUT: «0.617369623783555»say cotan(45); # OUTPUT: «0.617369623783555»
例程 acotan§
sub acotan(Numeric(Cool))method acotan()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其弧度形式的 反正切。
say 45.acotan; # OUTPUT: «0.0222185653267191»say acotan(45) # OUTPUT: «0.0222185653267191»
例程 sinh§
sub sinh(Numeric(Cool))method sinh()
将调用者（或在方法形式中，其参数）强制转换为 Numeric，并返回其 双曲正弦。
say 1.sinh; # OUTPUT: «1.1752011936438»say sinh(1); # OUTPUT: «1.1752011936438»
例程 asinh§
sub asinh(Numeric(Cool))method asinh()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 反双曲正弦。
say 1.asinh; # OUTPUT: «0.881373587019543»say asinh(1); # OUTPUT: «0.881373587019543»
例程 cosh§
sub cosh(Numeric(Cool))method cosh()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 双曲余弦。
say cosh(0.5); # OUTPUT: «1.12762596520638»
例程 acosh§
sub acosh(Numeric(Cool))method acosh()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 反双曲余弦。
say acosh(45); # OUTPUT: «4.4996861906715»
例程 tanh§
sub tanh(Numeric(Cool))method tanh()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，将其解释为弧度，并返回其 双曲正切。
say tanh(0.5); # OUTPUT: «0.46211715726001»say tanh(atanh(0.5)); # OUTPUT: «0.5»
例程 atanh§
sub atanh(Numeric(Cool))method atanh()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 反双曲正切。
say atanh(0.5); # OUTPUT: «0.549306144334055»
例程 sech§
sub sech(Numeric(Cool))method sech()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 双曲正割。
say 0.sech; # OUTPUT: «1»
例程 asech§
sub asech(Numeric(Cool))method asech()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 双曲余割。
say 0.8.asech; # OUTPUT: «0.693147180559945»
例程 cosech§
sub cosech(Numeric(Cool))method cosech()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 双曲余割。
say cosech(pi/2); # OUTPUT: «0.434537208094696»
例程 acosech§
sub acosech(Numeric(Cool))method acosech()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 双曲余割。
say acosech(4.5); # OUTPUT: «0.220432720979802»
例程 cotanh§
sub cotanh(Numeric(Cool))method cotanh()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 双曲余切。
say cotanh(pi); # OUTPUT: «1.00374187319732»
例程 acotanh§
sub acotanh(Numeric(Cool))method acotanh()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回其 双曲余切。
say acotanh(2.5); # OUTPUT: «0.423648930193602»
例程 cis§
sub cis(Numeric(Cool))method cis()
将调用者（或在子例程形式中，其参数）强制转换为 Numeric，并返回 cos(参数) + i*sin(参数)。
say cis(pi/4); # OUTPUT: «0.707106781186548+0.707106781186547i»
例程 log§
multi log(Numeric(Cool) , Numeric(Cool) ?)multi method log(Cool: Cool ?)
将参数（包括方法形式中的调用者）强制转换为 Numeric，并返回其以 $base 为底的 对数，或如果未提供底数，则以 e（欧拉数）为底（自然对数）。如果 $base 为 1，则抛出异常。
say (e*e).log; # OUTPUT: «2»
对于负数参数返回NaN。从 6.e 语言版本开始（Rakudo 编译器 2023.02+ 中存在早期实现），将为负数参数返回一个 Complex 值。
例程 log10§
multi method log10()multi log10(Numeric )multi log10(Cool )
将调用者（或在子例程形式中，参数）强制转换为 Numeric（或如果已为该形式，则直接使用），并返回其以 10 为底的 对数，即当 10 乘以其幂时近似产生原始数字的数字。对于 0，返回 -Inf。
say log10(1001); # OUTPUT: «3.00043407747932»
对于负数参数返回NaN。从 6.e 语言版本开始（Rakudo 编译器 2023.02+ 中存在早期实现），将为负数参数返回一个 Complex 值。
例程 log2§
multi method log2()multi log2(Numeric )multi log2(Cool )
将调用者强制转换为 Numeric，并返回其以 2 为底的 对数，即当 2 乘以其幂时近似（由于计算机精度限制）产生原始数字的数字。对于 0，返回 -Inf。
say log2(5); # OUTPUT: «2.321928094887362»say "4".log2; # OUTPUT: «2»say 4.log2; # OUTPUT: «2»
对于负数参数返回NaN。从 6.e 语言版本开始（Rakudo 编译器 2023.02+ 中存在早期实现），将为负数参数返回一个 Complex 值。
例程 exp§
multi exp(Cool , Cool ?)multi method exp(Cool: Cool ?)
将参数（包括方法形式中的调用者）强制转换为 Numeric，并返回 $base 乘以第一个数字的幂。如果未提供 $base，则使用 e（欧拉数）。
say 0.exp; # OUTPUT: «1»say 1.exp; # OUTPUT: «2.71828182845905»say 10.exp; # OUTPUT: «22026.4657948067»
方法 unpolar§
method unpolar(Numeric(Cool))
将参数（包括方法形式中的调用者）强制转换为 Numeric，并从给定的极坐标返回一个复数。调用者（或子形式中的第一个参数）是幅度，而参数（即子形式中的第二个参数）是角度。角度假定为弧度。
say sqrt(2).unpolar(pi/4); # OUTPUT: «1+1i»
例程 round§
multi round(Numeric(Cool), = 1)multi method round(Cool: = 1)
将调用者（或在子形式中，其参数）强制转换为 Numeric，并将其四舍五入到 $scale 的单位。如果 $scale 为 1，则四舍五入到最接近的整数；任意比例将导致该数字最接近的倍数。
say 1.7.round; # OUTPUT: «2»say 1.07.round(0.1); # OUTPUT: «1.1»say 21.round(10); # OUTPUT: «20»say round(1000, 23.01) # OUTPUT: «989.43»
如果数字处于中点，则始终向上舍入
say (−.5 ).round; # OUTPUT: «0»say ( .5 ).round; # OUTPUT: «1»say (−.55).round(.1); # OUTPUT: «-0.5»say ( .55).round(.1); # OUTPUT: «0.6»
使用此方法时，请注意类型，因为最终使用错误的类型可能会影响您想要达到的精度。对于 Real 类型，结果的类型是参数的类型（Complex 参数被强制转换为 Real，最终成为 Num）。如果舍入 Complex，则结果也为 Complex，无论参数的类型如何。
9930972392403501.round(1) .raku.say; # OUTPUT: «9930972392403501»9930972392403501.round(1e0) .raku.say; # OUTPUT: «9.9309723924035e+15»9930972392403501.round(1e0).Int.raku.say; # OUTPUT: «9930972392403500»
例程 floor§
multi floor(Numeric(Cool))multi method floor
将调用者（或在子形式中，其参数）强制转换为 Numeric，并向下舍入到最接近的整数。
say "1.99".floor; # OUTPUT: «1»say "-1.9".floor; # OUTPUT: «-2»say 0.floor; # OUTPUT: «0»
方法 fmt§
method fmt( = '%s')
使用 $format 返回调用者的格式化表示形式；等效于使用 $format 作为格式和调用者作为第二个参数调用 sprintf。$format 将被强制转换为 Stringy，并且默认为 '%s'。
有关格式字符串的更多信息，请参阅 sprintf。
say 11.fmt('This Int equals %03d'); # OUTPUT: «This Int equals 011»say '16'.fmt('Hexadecimal %x'); # OUTPUT: «Hexadecimal 10»
例程 ceiling§
multi ceiling(Numeric(Cool))multi method ceiling
将调用者（或在子形式中，其参数）强制转换为 Numeric，并向上舍入到最接近的整数。
say "1".ceiling; # OUTPUT: «1»say "-0.9".ceiling; # OUTPUT: «0»say "42.1".ceiling; # OUTPUT: «43»
例程 truncate§
multi truncate(Numeric(Cool))multi method truncate()
将调用者（或在子形式中，其参数）强制转换为 Numeric，并朝零舍入。
say 1.2.truncate; # OUTPUT: «1»say truncate -1.2; # OUTPUT: «-1»
例程 ord§
sub ord(Str(Cool))method ord()
将调用者（或在子形式中，其参数）强制转换为 Str，并返回第一个代码点的 Unicode 代码点 编号。
say 'a'.ord; # OUTPUT: «97»
逆运算为 chr。
助记符：返回序数
方法 path§
method path(Cool: --> IO::Path)
已弃用。自 6.d 版本起已弃用。将在下一个版本中删除。
将调用者字符串化并转换为 IO::Path 对象。请改用 .IO 方法。
例程 chr§
sub chr(Int(Cool))method chr()
将调用者（或在子例程形式中，其参数）强制转换为 Int，将其解释为 Unicode 代码点，并返回由该代码点组成的 Str。
say '65'.chr; # OUTPUT: «A»
逆操作是 ord。
助记符：将整数转换为字符。
例程 chars§
multi chars(Cool )multi chars(Str )multi chars(str --> int)method chars(--> Int)
将调用者（或在子例程形式中，其参数）强制转换为 Str，并返回字符串中的字符数。请注意，在 JVM 上，您当前获取的是代码点，而不是字形。
say 'møp'.chars; # OUTPUT: «3»say 'ã̷̠̬̊'.chars; # OUTPUT: «1»say '👨👩👧👦🏿'.chars; # OUTPUT: «1»
如果字符串是本地的，则字符数也将作为本机 int 返回。
字形是用户可见字符。也就是说，这是用户认为的“字符”。
字形可以包含多个代码点。通常，当涉及到 Prepend 或 Extend 字符（也称为 组合字符）时，字形数和代码点数不同，但在许多其他情况下也可能发生这种情况。另一个示例是 \c[ZWJ]（零宽连接符）。
您可以检查字符的 Grapheme_Cluster_Break 属性，以查看其行为方式
say ‘ã̷̠̬̊’.uniprops(‘Grapheme_Cluster_Break’); # OUTPUT: «(Other Extend Extend Extend Extend)»say ‘👨👩👧👦🏿’.uniprops(‘Grapheme_Cluster_Break’); # OUTPUT: «(E_Base_GAZ ZWJ E_Base_GAZ ZWJ E_Base_GAZ ZWJ E_Base_GAZ E_Modifier)»
您可以在 Unicode 标准 中阅读有关字形的更多信息，Raku 严格遵循该标准，使用称为 NFG，字形范式 的方法来有效地表示它们。
例程 codes§
sub codes(Str(Cool))method codes()
将调用者（或在子例程形式中，其参数）强制转换为 Str，并返回 Unicode 代码点 的数量。
say 'møp'.codes; # OUTPUT: «3»
使用以下方法将获得相同的结果
say +'møp'.ords; # OUTPUT: «3»
ords 首先获取实际代码点，因此速度可能会有所不同。
例程 flip§
sub flip(Cool --> Str)method flip()
将调用者（或在子例程形式中，其参数）强制转换为 Str，并返回反转版本。
say 421.flip; # OUTPUT: «124»
例程 trim§
sub trim(Str(Cool))method trim()
将调用者（或在子例程形式中，其参数）强制转换为 Str，并返回删除前导和尾随空白的字符串。
my = ' abc '.trim;say "<$stripped>"; # OUTPUT: «<abc>»
例程 trim-leading§
sub trim-leading(Str(Cool))method trim-leading()
将调用者（或在子例程形式中，其参数）强制转换为 Str，并返回删除前导空白的字符串。
my = ' abc '.trim-leading;say "<$stripped>"; # OUTPUT: «<abc >»
例程 trim-trailing§
sub trim-trailing(Str(Cool))method trim-trailing()
将调用者（或在子例程形式中，其参数）强制转换为 Str，并返回删除尾随空白的字符串。
my = ' abc '.trim-trailing;say "<$stripped>"; # OUTPUT: «< abc>»
例程 lc§
sub lc(Str(Cool))method lc()
将调用者（或在子表单中，其参数）强制转换为 Str，并将其转换为小写。
say "ABC".lc; # OUTPUT: «abc»
例程 uc§
sub uc(Str(Cool))method uc()
将调用者（或在子表单中，其参数）强制转换为 Str，并将其转换为大写（大写字母）。
say "Abc".uc; # OUTPUT: «ABC»
例程 fc§
sub fc(Str(Cool))method fc()
将调用者（或在子表单中，其参数）强制转换为 Str，并返回 Unicode “大小写折叠”操作的结果，适用于进行不区分大小写的字符串比较。（通常，返回的字符串不太可能用于除比较之外的任何目的。）
say "groß".fc; # OUTPUT: «gross»
例程 tc§
sub tc(Str(Cool))method tc()
将调用者（或在子表单中，其参数）强制转换为 Str，并返回其第一个字母转换为标题大小写（或在不可用时转换为大写）。
say "abC".tc; # OUTPUT: «AbC»
例程 tclc§
sub tclc(Str(Cool))method tclc()
将调用者（或在子表单中，其参数）强制转换为 Str，并返回其第一个字母转换为标题大小写（或在不可用时转换为大写），以及将字符串的其余部分转换为小写。
say 'abC'.tclc; # OUTPUT: «Abc»
例程 wordcase§
sub wordcase(Str(Cool) , : = , Mu : = True)method wordcase(: = , Mu : = True)
将调用者（或在子表单中，第一个参数）强制转换为 Str，并通过 &filter 筛选与 $where 智能匹配的每个单词。使用默认筛选器（第一个字符转换为大写，其余转换为小写）和匹配器（接受所有内容），这会对每个单词进行标题大小写转换
say "raku programming".wordcase; # OUTPUT: «Raku Programming»
使用匹配器
say "have fun working on raku".wordcase(:where());# Have fun Working on Raku
使用自定义筛选器
say "have fun working on raku".wordcase(:filter(), :where());# HAVE fun WORKING on RAKU
例程 samecase§
sub samecase(Cool , Cool )method samecase(Cool: Cool )
将调用者（或在子表单中，第一个参数）强制转换为 Str，并对其调用 Str.samecase。
say "raKu".samecase("A_a_"); # OUTPUT: «Raku»say "rAKU".samecase("Ab"); # OUTPUT: «Raku»
例程 uniprop§
multi uniprop(Str, |c)multi uniprop(Int )multi uniprop(Int , Stringy )multi method uniprop(|c)
返回第一个字符的 Unicode 属性。如果未指定属性，则返回 通用类别。对于布尔属性，返回布尔值。可以使用 uniprops 例程获取字符串中每个字符的属性。
say 'a'.uniprop; # OUTPUT: «Ll»say '1'.uniprop; # OUTPUT: «Nd»say 'a'.uniprop('Alphabetic'); # OUTPUT: «True»say '1'.uniprop('Alphabetic'); # OUTPUT: «False»
子例程 uniprops§
sub uniprops(Str , Stringy = "General_Category")
将调用者解释为 Str，并返回每个字符的 Unicode 属性，作为 Seq。如果未指定属性，则返回 通用类别。对于布尔属性，返回布尔值。类似于 uniprop，但适用于传递的字符串中的每个字符。
例程 uniname§
sub uniname(Str(Cool) --> Str)method uniname(--> Str)
将调用者或第一个参数解释为 Str，并返回第一个字符的第一个代码点的 Unicode 代码点名称。有关处理多个代码点的例程，请参阅 uninames；有关相反方向的例程，请参阅 uniparse。
# Camelia in Unicodesay ‘»ö«’.uniname;# OUTPUT: «RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK»say "Ḍ̇".uniname; # Note, doesn't show "COMBINING DOT ABOVE"# OUTPUT: «LATIN CAPITAL LETTER D WITH DOT BELOW»# Find the char with the longest Unicode name.say (0..0x1FFFF).sort(*.uniname.chars)[].chr.uniname;# OUTPUT: «BOX DRAWINGS LIGHT DIAGONAL UPPER CENTRE TO MIDDLE RIGHT AND MIDDLE LEFT TO LOWER CENTRE»
自 2021.04 Rakudo 编译器发布起可用。
例程 uninames§
sub uninames(Str)method uninames()
返回 Seq，其中包含所提供 Str 中所有代码点的 Unicode 名称。
say ‘»ö«’.uninames.raku;# OUTPUT: «("RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK", "LATIN SMALL LETTER O WITH DIAERESIS", "LEFT-POINTING DOUBLE ANGLE QUOTATION MARK").Seq»
请注意此示例，它获取一个 Seq，其中每个元素都是一个 Seq，包含该字符中的所有代码点。
say "Ḍ̇'oh".comb>>.uninames.raku;# OUTPUT: «(("LATIN CAPITAL LETTER D WITH DOT BELOW", "COMBINING DOT ABOVE").Seq, ("APOSTROPHE",).Seq, ("LATIN SMALL LETTER O",).Seq, ("LATIN SMALL LETTER H",).Seq)»
有关所提供的 Str 中第一个字符的第一个代码点的名称，请参阅 uniname；有关相反方向的例程，请参阅 uniparse。
例程 unimatch§
multi unimatch(Str , |c)multi unimatch(Int , Stringy , Stringy = )
检查给定的整数代码点或给定字符串的第一个字母是否具有与您给定的值相等的 Unicode 属性。如果您提供了要检查的 Unicode 属性，则只有在该属性与给定值匹配时，它才会返回 True。
say unimatch 'A', 'Latin'; # OUTPUT: «True»say unimatch 'A', 'Latin', 'Script'; # OUTPUT: «True»say unimatch 'A', 'Ll'; # OUTPUT: «False»
最后一个属性对应于“小写字母”，这解释了它为什么返回 false。
例程 chop§
sub chop(Str(Cool))method chop()
将调用者（或在子形式中，其参数）强制转换为 Str，并返回删除最后一个字符后的字符串。
say 'raku'.chop; # OUTPUT: «rak»
例程 chomp§
sub chomp(Str(Cool))method chomp()
将调用者（或在子形式中，其参数）强制转换为 Str，并返回删除最后一个字符后的字符串（如果它是一个逻辑换行符）。
say 'ab'.chomp.chars; # OUTPUT: «2»say "a\n".chomp.chars; # OUTPUT: «1»
例程 substr§
sub substr(Str(Cool) , |c)method substr(|c)
将调用者（或在子形式中，第一个参数）强制转换为 Str，并使用参数调用 Str.substr。
例程 substr-rw§
multi method substr-rw(|) is rwmulti substr-rw(|) is rw
将调用者（或在子形式中，第一个参数）强制转换为 Str，并使用参数调用 Str.substr-rw。
例程 ords§
sub ords(Str(Cool) )method ords()
将调用者（或在子形式中，第一个参数）强制转换为 Str，并返回每个字符的 Unicode 代码点的列表。
say "Camelia".ords; # OUTPUT: «67 97 109 101 108 105 97»say ords 10; # OUTPUT: «49 48»
这是 ord 的列表返回版本。逆运算在 chrs 中。如果您只对代码点的数量感兴趣，codes 可能是一个更快的选择。
例程 chrs§
sub chrs(* --> Str)method chrs()
将调用者（或在子形式中，参数列表）强制转换为整数列表，并返回通过将每个整数解释为 Unicode 代码点并连接字符而创建的字符串。
say <67 97 109 101 108 105 97>.chrs; # OUTPUT: «Camelia»
例程 split§
multi split( Str , Str(Cool) , = Inf, :, :, :, :, :)multi split(Regex , Str(Cool) , = Inf, :, :, :, :, :)multi split(, Str(Cool) , = Inf, :, :, :, :, :)multi method split( Str , = Inf, :, :, :, :, :)multi method split(Regex , = Inf, :, :, :, :, :)multi method split(, = Inf, :, :, :, :, :)
将调用者（或在子形式中，第二个参数）强制转换为 Str，根据字符串中找到的分隔符将其拆分为多个部分，并将结果作为 Seq 返回。
如果 $delimiter 是一个字符串，则按字面意思搜索它，而不将其视为正则表达式。您还可以通过将它们指定为列表来提供多个分隔符，该列表可以混合 Cool 和 Regex 对象。
say split(';', "a;b;c").raku; # OUTPUT: «("a", "b", "c").Seq»say split(';', "a;b;c", 2).raku; # OUTPUT: «("a", "b;c").Seq»say split(';', "a;b;c,d").raku; # OUTPUT: «("a", "b", "c,d").Seq»say split(/\;/, "a;b;c,d").raku; # OUTPUT: «("a", "b", "c,d").Seq»say split(//, "a;b;c,d").raku; # OUTPUT: «("a", "b", "c", "d").Seq»say split(['a', /b+/, 4], '1a2bb345').raku; # OUTPUT: «("1", "2", "3", "5").Seq»
默认情况下，split 会省略匹配项，并仅返回字符串中未匹配的部分的列表。指定 :k, :v, :kv, :p 副词之一会更改此行为。将匹配项视为与不匹配部分交错的列表。
:v 交错该列表的值，如果在拆分中使用 Regex 作为匹配器，则这些值将是 Match 对象，如果使用 Cool 作为匹配器，则这些值将是 Str 对象。如果指定了多个分隔符，则将为所有分隔符生成 Match 对象，除非所有分隔符都是 Cool。
say 'abc'.split(/b/, :v); # OUTPUT: «(a ｢b｣ c)»say 'abc'.split('b', :v); # OUTPUT: «(a b c)»
:k 交错键，即索引
say 'abc'.split(/b/, :k); # OUTPUT: «(a 0 c)»
:kv 添加索引和匹配项
say 'abc'.split(/b/, :kv); # OUTPUT: «(a 0 ｢b｣ c)»
而 :p 将它们作为 Pair 添加，对值使用与 :v 相同的类型
say 'abc'.split(/b/, :p); # OUTPUT: «(a 0 => ｢b｣ c)»say 'abc'.split('b', :p); # OUTPUT: «(a 0 => b c)»
您只能在对 split 的一次调用中使用 :k, :v, :kv, :p 副词之一。
请注意，空块不会从结果列表中删除。对于该行为，请使用 :skip-empty 命名参数
say ("f,,b,c,d".split: /","/ ).raku; # OUTPUT: «("f", "", "b", "c", "d").Seq»say ("f,,b,c,d".split: /","/, :skip-empty).raku; # OUTPUT: «("f", "b", "c", "d").Seq»
例程 lines§
sub lines(Str(Cool))method lines()
将调用者（以及在子形式中，参数）强制转换为 Str，将其分解为行（去掉换行符），并返回行列表。
say lines("a\nb\n").join('|'); # OUTPUT: «a|b»say "some\nmore\nlines".lines.elems; # OUTPUT: «3»
此方法可以用作 IO::Path 的一部分来逐行处理文件，因为 IO::Path 对象继承自 Cool，例如：
for 'huge-csv'.IO.lines -># or if you'll be processing latermy = 'huge-csv'.IO.lines;
如果没有参数，子例程 lines 会对 $*ARGFILES 进行操作。
要修改就地值，请使用 is copy 来强制使用可写容器。
for .lines -> is copy
方法 words§
method words(Cool: |c)
将调用者（或第一个参数，如果它作为子例程调用）强制转换为 Str，并返回构成该字符串的单词列表。查看 Str.words 以获取其他参数及其含义。
say <The quick brown fox>.words.join('|'); # OUTPUT: «The|quick|brown|fox»say <The quick brown fox>.words(2).join('|'); # OUTPUT: «The|quick»
Cool 是许多其他类的基类，其中一些类（如 Match）可以转换为字符串。这是在这种情况下发生的事情
say ( "easy come, easy goes" ~~ m:g/(ea\w+)/).words(Inf);# OUTPUT: «(easy easy)»say words( "easy come, easy goes" ~~ m:g/(ea\w+)/ , ∞);# OUTPUT: «(easy easy)»
上面的示例说明了 words 可以调用的两种方式，第一个参数通过其签名转换为调用者。Inf 是第二个参数的默认值，因此在两种情况下（和形式）都可以简单地省略它。
只有空格（包括不换行空格）才算作单词边界
say <Flying on a Boeing 747>.words.join('|'); # OUTPUT: «Flying|on|a|Boeing|747»
在这种情况下，“Boeing 747”包含一个（仅在源代码中可见）不换行空格；words 仍然在它上面拆分（生成的）Str，即使原始数组只有 4 个元素也是如此
say <Flying on a Boeing 747>.join('|'); # OUTPUT: «Flying|on|a|Boeing 747»
请参阅 Str.words 以获取更多示例和调用它的方法。
routine comb§
multi comb(Regex , Cool , = *)multi comb(Str , Cool , = *)multi comb(Int , Cool , = *)multi method comb(|c)
返回一个Seq，其中包含所有（或如果提供，最多$limit）调用者（方法形式）或第二个参数（子形式）与Regex、字符串或已定义数字的匹配项。
say "6 or 12".comb(/\d+/).join(", "); # OUTPUT: «6, 12»say comb(/\d /,(11..30)).join("--");# OUTPUT:# «11--12--13--14--15--16--17--18--19--21--22--23--24--25--26--27--28--29»
第二个语句举例说明了comb的第一种形式，其中Regex排除了十的倍数，而Range（即Cool）作为$input。comb在对结果字符串应用.comb之前将Range字符串化。查看Str.comb以了解其对不同类型的输入字符串的影响。当第一个参数是整数时，它表示将输入划分的块的（最大）大小
say comb(3,[3,33,333,3333]).join("*"); # OUTPUT: «3 3*3 3*33 *333*3»
在这种情况下，输入是一个列表，在转换为Str（包括空格）后，它被分成大小为 3 的块。
method contains§
method contains(Cool: |c)
将调用者强制转换为Str，并在其上调用Str.contains。请参阅该版本的 method 以了解参数和一般语法。
say 123.contains("2")# OUTPUT: «True»
由于Int是Cool的子类，因此123被强制转换为Str，然后对其调用contains。
say (1,1, * + * … * > 250).contains(233)# OUTPUT: «True»
Seq也是Cool的子类，它们被字符串化为逗号分隔的形式。在这种情况下，我们还使用Int，它也将被字符串化；"233"包含在该序列中，因此它返回True。请注意，此序列不是惰性的；由于明显的原因，惰性序列的字符串化不包括其每个组件。
routine index§
multi index(Cool , Cool , :i(:), :m(:) --> Int)multi index(Cool , Cool , Cool , :i(:), :m(:) --> Int)multi method index(Cool: Cool --> Int)multi method index(Cool: Cool , :m(:)! --> Int)multi method index(Cool: Cool , :i(:)!, :m(:) --> Int)multi method index(Cool: Cool , Cool --> Int)multi method index(Cool: Cool , Cool , :m(:)! --> Int)multi method index(Cool: Cool , Cool , :i(:)!, :m(:) --> Int)
将前两个参数（在方法形式中，也计算调用者）强制转换为Str，并从$pos开始在字符串$s中搜索$needle。它返回在其中找到$needle的字符串中的偏移量，如果未找到，则返回Nil。
有关示例，请参阅类型 Str 中的文档。
routine rindex§
multi rindex(Cool , Cool --> Int)multi rindex(Cool , Cool , Cool --> Int)multi method rindex(Cool: Cool --> Int)multi method rindex(Cool: Cool , Cool --> Int)
将前两个参数（包括方法形式中的调用者）强制转换为Str，将$pos强制转换为Int，并返回字符串中$needle的最后一个位置，该位置不在$pos之后。如果未找到$needle，则返回Nil。
有关示例，请参阅类型 Str 中的文档。
method match§
method match(Cool: , *)
将调用者强制转换为Stringy，并在其上调用方法match。
例程 roots§
multi roots(Numeric(Cool) , Int(Cool) )multi method roots(Int(Cool) )
将第一个参数（以及方法形式中，调用者）强制转换为 Numeric，将第二个参数（$n）强制转换为 Int，并生成一个包含 $n 个 Complex $n 次根的列表，这意味着将这些数字提升到 $n 次方后，大约会生成原始数字。
例如
my = 16;my = .roots(4);say ;for -># OUTPUT:«2+0i 1.22464679914735e-16+2i -2+2.44929359829471e-16i -3.67394039744206e-16-2i»# OUTPUT:«1.77635683940025e-15»# OUTPUT:«4.30267170434156e-15»# OUTPUT:«8.03651692704705e-15»# OUTPUT:«1.04441561648202e-14»
方法 subst§
method subst(|)
将调用者强制转换为 Stringy 并调用 Str.subst。
方法 trans§
method trans(|)
方法 IO§
method IO(--> IO::Path)
将调用者强制转换为 IO::Path。
.say for '.'.IO.dir; # gives a directory listing
方法 sprintf§
method sprintf(*)
根据一系列在许多语言中常见的 格式指令返回一个字符串；对象将是格式字符串，而提供的参数将根据它进行格式化。
"% 6s".sprintf('Þor').say; # OUTPUT: « Þor»
方法 printf§
method printf(*)
使用对象（只要它是 格式字符串），对参数进行格式化和打印
"%.8f".printf(now - now ); # OUTPUT: «-0.00004118»
方法 Complex§
multi method Complex()
将调用者强制转换为 Numeric 并调用其 .Complex 方法。如果无法强制转换为 Numeric，则 失败。
say 1+1i.Complex; # OUTPUT: «1+1i»say π.Complex; # OUTPUT: «3.141592653589793+0i»say <1.3>.Complex; # OUTPUT: «1.3+0i»say (-4/3).Complex; # OUTPUT: «-1.3333333333333333+0i»say "foo".Complex.^name; # OUTPUT: «Failure»
方法 FatRat§
multi method FatRat()
将调用者强制转换为 Numeric 并调用其 .FatRat 方法。如果无法强制转换为 Numeric，则 失败。
say 1+0i.FatRat; # OUTPUT: «1»say 2e1.FatRat; # OUTPUT: «20»say 1.3.FatRat; # OUTPUT: «1.3»say (-4/3).FatRat; # OUTPUT: «-1.333333»say "foo".FatRat.^name; # OUTPUT: «Failure»
方法 Int§
multi method Int()
将调用者强制转换为 Numeric 并调用其 .Int 方法。如果无法强制转换为 Numeric，则 失败。
say 1+0i.Int; # OUTPUT: «1»say <2e1>.Int; # OUTPUT: «20»say 1.3.Int; # OUTPUT: «1»say (-4/3).Int; # OUTPUT: «-1»say "foo".Int.^name; # OUTPUT: «Failure»
方法 Num§
multi method Num()
将调用者强制转换为 Numeric 并调用其 .Num 方法。如果无法强制转换为 Numeric，则 失败。
say 1+0i.Num; # OUTPUT: «1»say 2e1.Num; # OUTPUT: «20»say (16/9)².Num; # OUTPUT: «3.1604938271604937»say (-4/3).Num; # OUTPUT: «-1.3333333333333333»say "foo".Num.^name; # OUTPUT: «Failure»
方法 Rat§
multi method Rat()
将调用者强制转换为 Numeric 并调用其 .Rat 方法。如果无法强制转换为 Numeric，则 失败。
say 1+0i.Rat; # OUTPUT: «1»say 2e1.Rat; # OUTPUT: «20»say (-4/3).Rat; # OUTPUT: «-1.333333»say "foo".Rat.^name; # OUTPUT: «Failure»say (.numerator, .denominator) for π.Rat; # OUTPUT: «(355 113)»
方法 Real§
multi method Real()
将调用者强制转换为 Numeric 并调用其 .Real 方法。如果无法强制转换为 Numeric，则 失败。
say 1+0i.Real; # OUTPUT: «1»say 2e1.Real; # OUTPUT: «20»say 1.3.Real; # OUTPUT: «1.3»say (-4/3).Real; # OUTPUT: «-1.333333»say "foo".Real.^name; # OUTPUT: «Failure»
方法 UInt§
multi method UInt()
将调用者强制转换为 Int。如果无法强制转换为 Int 或调用者强制转换后的 Int 为负数，则 失败。
say 1+0i.UInt; # OUTPUT: «1»say 2e1.UInt; # OUTPUT: «20»say 1.3.UInt; # OUTPUT: «1»say (-4/3).UInt.^name; # OUTPUT: «Failure»say "foo".UInt.^name; # OUTPUT: «Failure»
方法 uniparse§
method uniparse(Cool: --> Str)
从 Rakudo 编译器 2021.04 版本开始可用。
将调用者强制转换为 Str，然后调用该 uniparse。这通常仅对 Match 对象有意义。
方法 Order§
method Order(Cool: --> Order)
从 Rakudo 编译器 2022.02 版本开始可用。
将调用者强制转换为 Int，然后返回 Order 枚举之一：如果为负数，则为 Less；如果为 0，则为 Same；如果为正数，则为 More。
方法 Failure§
method Failure(Cool: --> Failure)
从 Rakudo 编译器 2022.06 版本开始可用。
使用调用者的字符串化创建一个 X::AdHoc 异常，并将其强制转换为 Failure 对象。主要目的是减少代码中错误分支的字节码，以增加热代码内联的机会。
类型图§
Cool 的类型关系