Raku 入门

wget https://rakudo.perl6.org/downloads/star/rakudo-star-2019.03.tar.gz
tar xfz rakudo-star-2019.03.tar.gz
cd rakudo-star-2019.03
perl Configure.pl --gen-moar --make-install --prefix ~/rakudo

say 'hello world';

'hello world'.say;

#字符串
my $name = 'John Doe';
say $name;

#整数
my $age = 99;
say $age;

my $name = 'John Doe'; # 对于字符串类型
say $name.uc;          # .uc 将字母全部大写
say $name.chars;       # .chars 获得字符串的字符数, 即字符串长度
say $name.flip;        # .flip 返回翻转字符串的结果

JOHN DOE
8
eoD nhoJ

my $age = 17;
say $age.is-prime; # .is-prime 判断整数值是否为质数

True

my $age = 2.3;
say $age.numerator;   # .numerator 获得有理数值对应最简分数的分子
say $age.denominator; # .denominator 获得有理数值对应最简分数的分母
say $age.nude;        # .nude 同时获得分子分母

23
10
(23 10)

my @animals = 'camel','llama','owl';
say @animals;

my @animals = 'camel','vicuña','llama';
say "动物园容纳了 " ~ @animals.elems ~ " 只动物";
say "这些动物是: " ~ @animals;
say "动物园收养了一只 owl";
@animals.push("owl");
say "现在动物园有: " ~ @animals;
say "动物园收养的第一只动物是 " ~ @animals[0];
@animals.pop;
say "不幸的是， owl 走了，还剩下: " ~ @animals;
say "我们要关闭动物园，只留下一只动物";
say "我们要放走: " ~ @animals.splice(1,2) ~ " ，只剩下 " ~ @animals;

动物园容纳了 3 只动物
这些动物是: camel vicuña llama
动物园收养了一只 owl
现在动物园有: camel vicuña llama owl
动物园收养的第一只动物是 camel
不幸的是， owl 走了，还剩下: camel vicuña llama
我们要关闭动物园，只留下一只动物
我们要放走: vicuña llama ，只剩下 camel

my %capitals = ('UK','London','Germany','Berlin');
say %capitals;

my %capitals = (UK => 'London', Germany => 'Berlin');
say %capitals;

my %capitals = (UK => 'London', Germany => 'Berlin');
%capitals.push: (France => 'Paris');
say %capitals.kv;
say %capitals.keys;
say %capitals.values;
say "The capital of France is: " ~ %capitals<France>;

(France Paris Germany Berlin UK London)
(France Germany UK)
(Paris Berlin London)
The capital of France is: Paris

my $var = 'Text';
say $var;
say $var.WHAT;

$var = 123;
say $var;
say $var.WHAT;

my Int $var = 'Text';
say $var;
say $var.WHAT;

my Int @array = 1,2,3;
say @array;
say @array.WHAT;

my Str @multilingual = "Hello","Salut","Hallo","你好","안녕하세요","こんにちは";
say @multilingual;
say @multilingual.WHAT;

my Str %capitals = (UK => 'London', Germany => 'Berlin');
say %capitals;
say %capitals.WHAT;

my Int %country-codes = (UK => 44, Germany => 49);
say %country-codes;
say %country-codes.WHAT;

my Str %student-name{Int} = (1 => 'Alex', 2 => 'Mary');
say %student-name;
say %student-name.WHAT;

my Int $var;
say $var.WHAT;    # (Int)
my $var2;
say $var2.WHAT;   # (Any)
$var2 = 1;
say $var2.WHAT;   # (Int)
$var2 = "Hello";
say $var2.WHAT;   # (Str)
$var2 = True;
say $var2.WHAT;   # (Bool)
$var2 = Nil;
say $var2.WHAT;   # (Any)

my $var=1;

{
  my Str $var = 'Text';
  say $var; # 可以使用
}
say $var;   # 不能使用, 会报错

{
  my Str $var = 'Text';
  say $var;
}
my Int $var = 123;
say $var;

my Int $var = 123;
say $var;

my Int $var = 123;
say $var;
$var = 999;
say $var;

123
999

my Int $var := 123;
say $var;
$var = 999;
say $var;

123
Cannot assign to an immutable value 不允许赋值到一个不可变值

my $a;
my $b;
$b := $a;
$a = 7;
say $b;
$b = 8;
say $a;

7
8

my $age = 19;

if $age > 18 {
  say 'Welcome'
}

my $age = 19;

say 'Welcome' if $age > 18;

# 为变量不同的值运行相同的代码
my $座位数 = 9;

if $座位数 <= 5 {
  say '我是小轿车'
} elsif $座位数 <= 7 {
  say '我是七座车'
} else {
  say '我是面包车'
}

my $clean-shoes = False;

if not $clean-shoes {
  say 'Clean your shoes'
}

my $clean-shoes = False;

unless $clean-shoes {
  say 'Clean your shoes'
}

my Int $var=1;

with $var {
  say 'Hello'
}

my Int $var;

with $var {
  say 'Hello'
}

my @array = [1,2,3];

for @array -> $array-item {
  say $array-item * 100
}

my $var = 42;

given $var {
    when 0..50 { say 'Less than or equal to 50'}
    when Int { say "is an Int" }
    when 42  { say 42 }
    default  { say "huh?" }
}

my $var = 42;

given $var {
    when 0..50 { say 'Less than or equal to 50';proceed}
    when Int { say "is an Int";proceed}
    when 42  { say 42 }
    default  { say "huh?" }
}

loop (my $i = 0; $i < 5; $i++) {
  say "The current number is $i"
}

my $name = 'Neo';
run 'echo', "hello $name";
shell "ls";

shell "dir";

say dir;              # 列出当前目录下的文件和文件夹
say dir "/Documents"; # 列出特定目录下的文件和文件夹

mkdir "newfolder";
rmdir "newfolder";

say "script123.raku".IO.e;
say "folder123".IO.e;

say "script123.raku".IO.d;
say "folder123".IO.d;

say "script123.raku".IO.f;
say "folder123".IO.f;

sub alien-greeting {
  say "Hello earthlings";
}

alien-greeting;

sub say-hello (Str $name) {
    say "Hello " ~ $name ~ "!!!!"
}
say-hello "Paul";
say-hello "Paula";

multi greet($name) {
    say "Good morning $name";
}
multi greet($name, $title) {
    say "Good morning $title $name";
}

greet "Johnnie";
greet "Laura","Mrs.";

sub say-hello($name?) {
  with $name { say "Hello " ~ $name }
  else { say "Hello Human" }
}
say-hello;
say-hello("Laura");

sub say-hello($name="Matt") {
  say "Hello " ~ $name;
}
say-hello;
say-hello("Laura");

sub squared ($x) {
  $x ** 2;
}
say "7 squared is equal to " ~ squared(7);

sub squared ($x) {
  return $x ** 2;
}
say "7 squared is equal to " ~ squared(7);

my @array = <1 2 3 4 5>;
sub squared($x) {
    $x ** 2
}
say map(&squared, @array);

(1 4 9 16 25)

my @array = <1 2 3 4 5>;
say map(-> $x {$x ** 2}, @array);

my $squared = -> $x {
    $x ** 2
}
say $squared(9);

my @array       = <7 8 9 0 1 2 4 3 5 6 7 8 9 >;
my @final-array = reverse(sort(unique(@array)));
say @final-array;

my @array       = <7 8 9 0 1 2 4 3 5 6 7 8 9 >;
my @final-array = @array.unique.sort.reverse;
say @final-array;

my @array = <7 8 9 0 1 2 4 3 5 6>;
@array ==> unique()
       ==> sort()
       ==> reverse()
       ==> my @final-array;
say @final-array;

从 `@array` 开始 然后 返回一个唯一元素的列表
                然后 排序它
                然后 反转它
                然后 把结果保存到 @final-array 中

my @array = <7 8 9 0 1 2 4 3 5 6>;
my @final-array-v2 <== reverse()
                   <== sort()
                   <== unique()
                   <== @array;
say @final-array-v2;

my @array = <0 1 2 3 4 5 6 7 8 9 10>;
sub is-even($var) { $var %% 2 };

say @array>>.is-prime;
say @array>>.&is-even;

my $var = 2;
if $var == 1|2|3 {
    say "The variable is 1 or 2 or 3"
}

. 简单惰性列表
----
my  $lazylist = (1 ... 10);
say $lazylist;
----

. 无穷惰性列表
----
my  $lazylist = (1 ... Inf);
say $lazylist;
----

my  $lazylist = (0,2 ... 10);
say $lazylist;

my  $lazylist = (0, { $_ + 3 } ... 12);
say $lazylist;

sub generate-greeting {
    my $name = "John Doe";
    sub greeting {
      say "Good Morning $name";
    };
    return &greeting;
}
my $generated = generate-greeting;
$generated();

sub greeting-generator($period) {
  return sub ($name) {
    return "Good $period $name"
  }
}
my $morning = greeting-generator("Morning");
my $evening = greeting-generator("Evening");

say $morning("John");
say $evening("Jane");

class Human {
  has $.name;
  has $.age;
  has $.sex;
  has $.nationality;
}

my $john = Human.new(name => 'John', age => 23, sex => 'M', nationality => 'American');
say $john;

my class Human {

}

my  $var = 7;
say $var;

my $var = 7;
sub sayvar {
    $var;
}
say sayvar;

class Human {
    has $!name;
    has $!age;
    has $!sex;
    has $!nationality;
}

my $john = Human.new(name => 'John', age => 23, sex => 'M', nationality => 'American');
say $john;

class Human {
    has $.name;
    has $.age;
    has $.sex;
    has $.nationality;

    # 重写默认构造函数的新构造函数
    method new ($name, $age, $sex, $nationality) {
        self.bless(:$name, :$age, :$sex, :$nationality);
    }
}

my $john = Human.new('John', 23, 'M', 'American');
say $john;

class Human {
    has $.name;
    my  $.counter = 0;
    method new($name) {
      Human.counter++;
      self.bless(:$name);
    }
}
my $a = Human.new('a');
my $b = Human.new('b');

say Human.counter;

class Human {
    has $.name;
    has $.age is rw;
}
my $john = Human.new(name => 'John', age => 21);
say $john.age;

$john.age = 23;
say $john.age;

class bar-chart {
  has Int @.bar-values;
  method plot {
    say @.bar-values;
  }
}

class line-chart {
  has Int @.line-values;
  method plot {
    say @.line-values;
  }
}

class combo-chart is bar-chart is line-chart {
}

my $actual-sales   = bar-chart.new(bar-values => [10,9,11,8,7,10]);
my $forecast-sales = line-chart.new(line-values => [9,8,10,7,6,9]);

my $actual-vs-forecast = combo-chart.new(bar-values => [10,9,11,8,7,10],
                                         line-values => [9,8,10,7,6,9]);
say "实际的销售: ";
$actual-sales.plot;
say "预测的销售: ";
$forecast-sales.plot;
say "实际 vs 预测:";
$actual-vs-forecast.plot;

实际的销售:
[10 9 11 8 7 10]
预测的销售:
[9 8 10 7 6 9]
实际 vs 预测:
[10 9 11 8 7 10]

class bar-chart {
  has Int @.bar-values;
  method plot {
    say @.bar-values;
  }
}

class line-chart {
  has Int @.line-values;
  method plot {
    say @.line-values;
  }
}

class combo-chart is bar-chart is line-chart {
  method plot {
    say @.bar-values;
    say @.line-values;
  }
}

my $actual-sales = bar-chart.new(bar-values => [10,9,11,8,7,10]);
my $forecast-sales = line-chart.new(line-values => [9,8,10,7,6,9]);

my $actual-vs-forecast = combo-chart.new(bar-values => [10,9,11,8,7,10],
                                         line-values => [9,8,10,7,6,9]);
say "实际的销售: ";
$actual-sales.plot;
say "预测的销售: ";
$forecast-sales.plot;
say "实际 vs 预测:";
$actual-vs-forecast.plot;

实际的销售:
[10 9 11 8 7 10]
预测的销售:
[9 8 10 7 6 9]
实际 vs 预测:
[10 9 11 8 7 10]
[9 8 10 7 6 9]

role bar-chart {
  has Int @.bar-values;
  method plot {
    say @.bar-values;
  }
}

role line-chart {
  has Int @.line-values;
  method plot {
    say @.line-values;
  }
}

class combo-chart does bar-chart does line-chart {
  method plot {
    say @.bar-values;
    say @.line-values;
  }
}

my $actual-sales = bar-chart.new(bar-values => [10,9,11,8,7,10]);
my $forecast-sales = line-chart.new(line-values => [9,8,10,7,6,9]);

my $actual-vs-forecast = combo-chart.new(bar-values => [10,9,11,8,7,10],
                                         line-values => [9,8,10,7,6,9]);
say "实际的销售: ";
$actual-sales.plot;
say "预测的销售: ";
$forecast-sales.plot;
say "实际 vs 预测:";
$actual-vs-forecast.plot;

role bar-chart {
  has Int @.bar-values;
  method plot {
    say @.bar-values;
  }
}

role line-chart {
  has Int @.line-values;
  method plot {
    say @.line-values;
  }
}

class combo-chart does bar-chart does line-chart {
}

my $actual-sales = bar-chart.new(bar-values => [10,9,11,8,7,10]);
my $forecast-sales = line-chart.new(line-values => [9,8,10,7,6,9]);

my $actual-vs-forecast = combo-chart.new(bar-values => [10,9,11,8,7,10],
                                         line-values => [9,8,10,7,6,9]);
say "Actual sales:";
$actual-sales.plot;
say "Forecast sales:";
$forecast-sales.plot;
say "Actual vs Forecast:";
$actual-vs-forecast.plot;

===SORRY!===
Method 'plot' must be resolved by class combo-chart because it exists in multiple roles (line-chart, bar-chart)
类'combo-chart'的方法'plot'必须被决定，因为存在多个role（line-chart, bar-chart）

class Human {
  has Str $.name;
  has Int $.age;
  method introduce-yourself {
    say 'Hi I am a human being, my name is ' ~ self.name;
  }
}

class Employee is Human {
  has Str $.company;
  has Int $.salary;
  method introduce-yourself {
    say 'Hi I am a employee, my name is ' ~ self.name ~ ' and I work at: ' ~ self.company;
  }
}

my $john = Human.new(name =>'John',age => 23,);
my $jane = Employee.new(name =>'Jane',age => 25,company => 'Acme',salary => 4000);

say $john.WHAT;
say $jane.WHAT;
say $john.^attributes;
say $jane.^attributes;
say $john.^methods;
say $jane.^methods;
say $jane.^parents;
if $jane ~~ Human {say 'Jane is a Human'};

class Human {
  has Str $.name;
  has Int $.age;
  method introduce-yourself {
    say 'Hi i am a human being, my name is ' ~ self.name;
  }
}

class Employee is Human {
  has Str $.company;
  has Int $.salary;
  method introduce-yourself {
    say 'Hi i am a employee, my name is ' ~ self.name ~ ' and I work at: ' ~ self.company;
  }
}

my $john = Human.new(name =>'John',age => 23,);
my $jane = Employee.new(name =>'Jane',age => 25,company => 'Acme',salary => 4000);

say $john.WHAT;
say $jane.WHAT;
say $john.^attributes;
say $jane.^attributes;
say $john.^methods;
say $jane.^methods;
say $jane.^parents;
if $jane ~~ Human {say 'Jane is a Human'};

my Str $name;
$name = "Joanna";
say "Hello " ~ $name;
say "How are you doing today?"

Hello Joanna
How are you doing today?

my Str $name;
$name = 123;
say "Hello " ~ $name;
say "今天过得怎么样？"

Type check failed in assignment to $name; expected Str but got Int 赋值给$name时类型检查失败，预期Str但是得到Int
   in block <unit> at exceptions.raku:2

my Str $name;
try {
  $name = 123;
  say "Hello " ~ $name;
  CATCH {
    default {
      say "请再说一次你的名字，我们在记录中找不到它。";
    }
  }
}
say "今天过得怎么样？";

请再说一次你的名字，我们在记录中找不到它。
今天过得怎么样？

try {
  # 代码在这里运行
  # 如果有东西出错, 脚本会进入到下面的 CATCH 块中
  # 如果什么错误也没有, 那么 CATCH 块会被忽略
  CATCH {
    default {
      # 只有抛出异常时, 这儿的代码才会被求值
    }
  }
}

try {
  # 代码在这里运行
  # 如果有东西出错, 脚本会进入到下面的 CATCH 块中
  # 如果什么错误也没有, 那么 CATCH 块会被忽略
  CATCH {
    when X::AdHoc { # 当异常 X::AdHoc 被抛出时要执行的操作 }
    when X::IO { # 当异常 X::IO 被抛出时要执行的操作}
    when X::OS { # 当异常 X::OS 被抛出时要执行的操作 }
    default { # 当异常类型不属于上述任何一种时要执行的操作}
  }
}

my Int $age = 21;
die "Error !";

my Int $age = 21;
X::AdHoc.new(payload => 'Error !').throw;

if 'Temperature: 13' ~~ m/ \: / {
    say "提供的字符串包含冒号 :";
}

if 'Age = 13' ~~ m/ '=' / {
    say "提供的字符串包含等号 = ";
}

if 'name@company.com' ~~ m/ "@" / {
    say "这是一个有效的电子邮件地址，因为它包含 @ 字符";
}

if "John123" ~~ / \d / {
  say "这不是有效名称，不允许使用数字";
} else {
  say "这是个有效名称"
}
if "John-Doe" ~~ / \s / {
  say "这个字符串包含空白";
} else {
  say "这个字符串不包含空白"
}

if "Devanagari Numbers १२३" ~~ / <:N> / {
  say "包含数字";
} else {
  say "不包含数字"
}

if "Привет, Иван." ~~ / <:Lu> / {
  say "包含大写字母";
} else {
  say "不包含大写字母"
}

if "John-Doe" ~~ / <:Pd> / {
  say "包含破折号";
} else {
  say "不包含破折号"
}

if 'abc' ~~ m/ a.c / {
    say "匹配";
}

if 'a2c' ~~ m/ a.c / {
    say "匹配";
}

if 'ac' ~~ m/ a.c / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'ac' ~~ m/ a?c / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'c' ~~ m/ a?c / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'az' ~~ m/ a*z / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'aaz' ~~ m/ a*z / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'aaaaaaaaaaz' ~~ m/ a*z / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'z' ~~ m/ a*z / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'az' ~~ m/ a+z / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'aaz' ~~ m/ a+z / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'aaaaaaaaaaz' ~~ m/ a+z / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'z' ~~ m/ a+z / {
    say "匹配";
  } else {
    say "不匹配";
}

if 'Rakudo is a Raku compiler' ~~ m/:s Raku/ {
    say "匹配的内容是：" ~ $/;
    say "匹配之前的字符串：" ~ $/.prematch;
    say "匹配之后的字符串：" ~ $/.postmatch;
    say "匹配从字符串此处开始：" ~ $/.from;
    say "匹配从字符串此处结束：" ~ $/.to;
}

匹配的内容是：Raku
匹配之前的字符串：Rakudo is a
匹配之后的字符串： compiler
匹配从字符串此处开始：12
匹配从字符串此处结束：18

my $email = 'john.doe@perl6.org';
my $regex = / <:L>+\.<:L>+\@<:L+:N>+\.<:L>+ /;

if $email ~~ $regex {
  say $/ ~ " 是一个合法的Email地址";
} else {
  say "这不是合法的Email地址";
}

my $email = 'john.doe@perl6.org';
my regex 多个字母 { <:L>+ };
my regex 点 { \. };
my regex at { \@ };
my regex 多个字母与数字 { <:L+:N>+ };

if $email ~~ / <多个字母> <点> <多个字母> <at> <多个字母与数字> <点> <多个字母> / {
  say $/ ~ " 是一个合法的Email地址";
} else {
  say "这不是合法的Email地址";
}

use Digest::MD5;
my $password = "password123";
my $hashed-password = Digest::MD5.new.md5_hex($password);

say $hashed-password;

say "a";
say "\x0061";
say "\c[LATIN SMALL LETTER A]";

say "☺";
say "\x263a";
say "\c[WHITE SMILING FACE]";

say "á";
say "\x00e1";
say "\x0061\x0301";
say "\c[LATIN SMALL LETTER A WITH ACUTE]";

say "á".NFC;
say "á".NFD;
say "á".uniname;

NFC:0x<00e1>
NFD:0x<0061 0301>
LATIN SMALL LETTER A WITH ACUTE

my $Δ = 1;
$Δ++;
say $Δ;

my $var = 2 + ⅒;
say $var;

#include <stdio.h>

void hellofromc () {
  printf("Hello from C\n");
}

gcc -c -fpic ncitest.c
gcc -shared -o libncitest.so ncitest.o

gcc -c ncitest.c
gcc -shared -o ncitest.dll ncitest.o

use NativeCall;

constant LIBPATH = "$*CWD/ncitest";
sub hellofromc() is native(LIBPATH) { * }

hellofromc();

use NativeCall;

constant LIBPATH = "$*CWD/ncitest";
sub hello() is native(LIBPATH) is symbol('hellofromc') { * }

hello();

#include <stdio.h>

void hellofromc (char* name) {
  printf("Hello, %s! This is C!\n", name);
}

use NativeCall;

constant LIBPATH = "$*CWD/ncitest";
sub hello(Str) is native(LIBPATH) is symbol('hellofromc') { * }

hello('Jane');

int add (int a, int b) {
  return (a + b);
}

use NativeCall;

constant LIBPATH = "$*CWD/ncitest";
sub add(int32,int32) returns int32 is native(LIBPATH) { * }

say add(2,3);