summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
-rw-r--r--perl6.html.markdown937
-rw-r--r--zh-cn/julia-cn.html.markdown729
2 files changed, 1666 insertions, 0 deletions
diff --git a/perl6.html.markdown b/perl6.html.markdown
new file mode 100644
index 00000000..6cacc672
--- /dev/null
+++ b/perl6.html.markdown
@@ -0,0 +1,937 @@
+---
+name: perl6
+category: language
+language: perl6
+filename: learnperl6.pl
+contributors:
+ - ["Nami-Doc", "http://github.com/Nami-Doc"]
+---
+
+Perl 6 is a highly capable, feature-rich programming language made for the upcoming hundred years.
+
+Perl 6 runs on [the Parrot VM](http://parrot.org/), the JVM and [the MoarVM](http://moarvm.com).
+
+Meta-note : the triple pound signs are here to denote headlines, double paragraphs, single notes.
+`#=>` represents the output of a command.
+
+```perl
+# Single line comment start with a pound
+
+#`(
+ Multiline comments use #` and a quoting construct. (), [], {}, 「」, etc, will work.
+)
+
+### Variables
+
+# In Perl 6, you declare a lexical variable using `my`
+a
+# Perl 6 has 4 variable types :
+
+## - Scalars. They represent a single value. They start with a `$`
+
+my $str = 'String';
+my $str2 = "String"; # double quotes allow for interpolation
+
+# variable names can contain but not end with simple quotes and dashes, and can contain (and end with) underscores :
+# my $weird'variable-name_ = 5; # works !
+
+my $bool = True; # `True` and `False` are Perl 6's boolean
+my $inverse = !$bool; # You can invert a bool with the prefix `!` operator
+my $forced-bool = so $str; # And you can use the prefix `so` operator which turns its operand into a Bool
+
+## - Arrays. They represent multiple values. Their name start with `@`.
+
+my @array = 1, 2, 3;
+my @array = 'a', 'b', 'c';
+# equivalent to :
+my @array = <a b c>; # array of words, delimited by space. similar to perl5's qw, or Ruby's %w
+
+say @array[2]; # Array indices start at 0 -- This is the third element
+
+say "Interpolate an array using [] : @array[]"; #=> Interpolate an array using [] : a b c
+
+## - Hashes. Key-Value Pairs.
+# Hashes are actually arrays of Pairs (`Key => Value`),
+# except they get "flattened", removing duplicated keys.
+my %hash = 1 => 2,
+ 3 => 4;
+my %hash = autoquoted => "key", # keys *can* get auto-quoted
+ "some other" => "value", # trailing commas are okay
+ ;
+my %hash = <key1 value1 key2 value2>; # you can also create a hash from an even-numbered array
+my %hash = key1 => 'value1', key2 => 'value2'; # same as this
+
+# You can also use the "colon pair" syntax: (especially handy for named parameters that you'll see later)
+my %hash = :w(1), # equivalent to `w => 1`
+ # this is useful for the `True` shortcut:
+ :truey, # equivalent to `:truey(True)`, or `truey => True`
+ # and for the `False` one:
+ :!falsey, # equivalent to `:falsey(False)`, or `falsey => False`
+ ;
+
+say %hash{'key1'}; # You can use {} to get the value from a key
+say %hash<key2>; # if it's a string, you can actually use <>
+
+## - Subs (subroutines, or functions in most other languages). Stored in variable, they use `&`
+sub say-hello { say "Hello, world" }
+
+sub say-hello-to(Str $name) { # you can provide the type of an argument
+ # and it'll be checked at compile-time
+
+ say "Hello, $name !";
+}
+
+# since you can omit parenthesis to call a function with no arguments,
+# you need "&" in the name to capture `say-hello`
+my &s = &say-hello;
+my &other-s = sub { say "anonymous function !" }
+
+# A sub can have a "slurpy" parameter, or "doesn't-matter-how-many"
+sub as-many($head, *@rest) { # the `*@` slurpy will basically "take everything else".
+ # Note: you can have parameters *before* (like here) a slurpy one,
+ # but not *after*.
+ say @rest.join(' / ') ~ " !";
+}
+say as-many('Happy', 'Happy', 'Birthday'); #=> Happy Birthday !
+ # Note that the splat did not consume the parameter before.
+
+## You can call a function with an array using the "argument list flattening" operator `|`
+# (it's not actually the only feature of the operator, but it's one of them)
+sub concat3($a, $b, $c) {
+ say "$a, $b, $c";
+}
+concat3(|@array); #=> a, b, c
+ # `@array` got "flattened" as a part of the argument list
+
+## It can also have optional arguments:
+sub with-optional($arg?) { # the "?" marks the argument optional
+ say "I might return `(Any)` if I don't have an argument passed, or I'll return my argument";
+ $arg;
+}
+with-optional; # returns Any
+with-optional(); # returns Any
+with-optional(1); # returns 1
+
+## You can also give them a default value when they're not passed:
+sub hello-to($name = "World") {
+ say "Hello, $name !";
+}
+hello-to; #=> Hello, World !
+hello-to(); #=> Hello, World !
+hello-to('You'); #=> Hello, You !
+
+## You can also, by using a syntax akin to the one of hashes (yay unification !),
+## pass *named* arguments to a `sub`.
+sub with-named($normal-arg, :$named) {
+ say $normal-arg + $named;
+}
+with-named(1, named => 6); #=> 7
+# There's one gotcha to be aware of, here:
+# If you quote your key, Perl 6 won't be able to see it as compile time,
+# and you'll have a single Pair object as a positional paramater.
+
+with-named(2, :named(5)); #=> 7
+with-named(3, :4named); #=> 7
+ # (special colon pair syntax for numbers, mainly useful for `:2nd` etc)
+
+with-named(3); # warns, because we tried to use the undefined $named in a `+`:
+ # by default, named arguments are *optional*
+
+# To make a named argument mandatory, you can use `?`'s inverse, `!`
+sub with-mandatory-named(:$str!) {
+ say "$named !";
+}
+with-mandatory-named(str => "My String"); #=> My String !
+with-mandatory-named; # run time error: "Required named parameter not passed"
+with-mandatory-named(3); # run time error: "Too many positional parameters passed"
+
+## If a sub takes a named boolean argument ...
+sub takes-a-bool($name, :$bool) {
+ say "$name takes $bool";
+}
+# ... you can use the same "short boolean" hash syntax:
+takes-a-bool('config', :bool); # config takes True
+takes-a-bool('config', :!bool); # config takes False
+# or you can use the "adverb" form:
+takes-a-bool('config'):bool; #=> config takes True
+takes-a-bool('config'):!bool; #=> config takes False
+# You'll learn to love (or maybe hate, eh) that syntax later.
+
+
+## You can also provide your named arguments with defaults:
+sub named-def(:$def = 5) {
+ say $def;
+}
+named-def; #=> 5
+named-def(:10def); #=> 10
+named-def(def => 15); #=> 15
+
+# -- Note: we're going to learn *more* on subs really soon,
+# but we need to grasp a few more things to understand their real power. Ready?
+
+### Containers
+# In Perl 6, values are actually stored in "containers".
+# the assignment operator asks the container on the left to store the value on its right
+# When passed around, containers are marked as immutable. Which means that, in a function,
+# you'll get an error if you try to mutate one of your argument.
+# If you really need to, you can ask for a mutable container using `is rw` :
+sub mutate($n is rw) {
+ $n++;
+ say "\$n is now $n !";
+}
+
+# If what you want is a copy instead, use `is copy`.
+
+# A sub itself returns a container, which means it can be marked as rw :
+my $x = 42;
+sub mod() is rw { $x }
+mod() = 52; # in this case, the parentheses are mandatory (else Perl 6 thinks it's a "term")
+say $x; #=> 52
+
+
+### Control Flow Structures
+
+# You don't need to put parenthesis around the condition,
+# but that also means you always have to use brackets (`{ }`) for their body :
+
+## Conditionals
+
+# - `if`
+if True {
+ say "It's true !";
+}
+
+unless False {
+ say "It's not false !";
+}
+
+# You can also use their postfix versions, with the keyword after:
+say "Quite truthy" if True;
+
+# if (true) say; # This doesn't work !
+
+# - Ternary conditional, "?? !!" (like `x ? y : z` in some other languages)
+my $a = $condition ?? $value-if-true !! $value-if-false;
+
+# - `given`-`when` looks like other languages `switch`, but it's much more powerful thanks to smart matching.
+# given just puts its argument into `$_` (like a block),
+# and `when` uses it using the "smart matching" operator.
+given "foo bar" {
+ when /foo/ { # you'll read about the smart-matching operator below -- just know `when` uses it
+ say "Yay !";
+ }
+ when $_.chars > 50 { # smart matching anything with True (`$a ~~ True`) is True,
+ # so you can also put "normal" conditionals.
+ say "Quite a long string !";
+ }
+ default { # same as `when *` (using the Whatever Star)
+ say "Something else"
+ }
+}
+
+## Looping constructs
+
+# - `loop` is an infinite loop if you don't pass it arguments, but can also be a c-style `for` :
+loop {
+ say "This is an infinite loop !";
+ last; # last breaks out of the loop, like the `break` keyword in other languages
+}
+
+loop (my $i = 0; $i < 5; $i++) {
+ next if $i == 3; # `next` skips to the next iteration, like `continue` in other languages.
+ # Notice that you can also use postfix conditionals, loops, etc.
+ say "This is a C-style for loop !";
+}
+
+# - `for` - Passes through an array
+for @array -> $variable {
+ say "I've found $variable !";
+}
+
+# default variable is $_ (like a block)
+for @array {
+ say "I've got $_";
+}
+
+for @array {
+ next if $_ == 3; # you can skip to the next iteration (like `continue` in C-like languages)
+ redo if $_ == 4; # you can re-do the iteration, keeping the same topic variable (`$_`)
+ last if $_ == 5; # you can also break out of a loop (like `break` in C-like languages)
+}
+
+# Note - the "lambda" `->` syntax isn't reserved to `for` :
+if long-computation() -> $result {
+ say "The result is $result";
+}
+
+### Operators
+
+## Since Perl languages are very much operator-based languages
+## Perl 6 operators are actually just funny-looking subroutines, in syntactic categories,
+## like infix:<+> (addition) or prefix:<!> (bool not)
+
+## The categories are :
+# - "prefix" : before (like `!` in `!True`).
+# - "postfix" : after (like `++` in `$a++`).
+# - "infix" : in between (like `*` in `4 * 3`).
+# - "circumfix" : around (like `[`-`]` in `[1, 2]`).
+# - "post-circumfix" : around, after another term (like `{`-`}` in `%hash{'key'}`)
+
+## The associativity and precedence list are explained below.
+
+# Alright, you're set to go !
+
+## * Equality Checking
+
+# - `==` is numeric comparison
+3 == 4; # False
+3 != 4; # True
+
+# - `eq` is string comparison
+'a' eq 'b';
+'a' ne 'b'; # not equal
+'a' !eq 'b'; # same as above
+
+# - `eqv` is canonical equivalence (or "deep equality")
+(1, 2) eqv (1, 3);
+
+# - `~~` is smart matching
+# for a complete combinations list, use this table : http://perlcabal.org/syn/S03.html#Smart_matching
+'a' ~~ /a/; # true if matches regexp
+'key' ~~ %hash; # true if key exists in hash
+$arg ~~ &bool-returning-function; # true if the function, passed `$arg` as an argument, returns True
+1 ~~ Int; # "is of type"
+1 ~~ True; # smart-matching against a boolean always returns that boolean (and will warn).
+
+# - `===` is value identity and uses `.WHICH` on the objects to compare them
+# - `=:=` is container identity and uses `VAR()` on the objects to compare them
+
+# You also, of course, have `<`, `<=`, `>`, `>=`.
+# Their string equivalent are also avaiable : `lt`, `le`, `gt`, `ge`.
+3 > 4;
+
+## * Range constructors
+3 .. 7; # 3 to 7, both included
+# `^` on either side them exclusive on that side :
+3 ^..^ 7; # 3 to 7, not included (basically `4 .. 6`)
+# this also works as a shortcut for `0..^N`
+^10; # means 0..^10
+
+# This also allows us to demonstrate that Perl 6 has lazy arrays, using the Whatever Star :
+my @array = 1..*; # 1 to Infinite !
+say @array[^10]; # you can pass arrays as subscripts and it'll return an array of results
+ # this will print "1 2 3 4 5 6 7 8 9 10" (and not run out of memory !)
+# Note : when reading an infinite list, Perl 6 will "reify" the elements it needs, then keep them in memory
+# They won't be calculated more than once.
+
+# Warning, though: if you try this example in the REPL and juste put `1..*`,
+# Perl 6 will be forced to try and evaluate the whole array (to print it),
+# so you'll end with an infinite loop.
+
+## * And, Or
+3 && 4; # True. Calls `.Bool` on `3`
+0 || False; # False. Calls `.Bool` on `0`
+
+## Short-circuit (and tight) versions of the above
+$a && $b && $c; # returns the first argument that evaluates to False, or the last argument
+$a || $b;
+
+### More on subs !
+# As we said before, Perl 6 has *really* powerful subs.
+# We're going to see a few more key concepts that make them better than in any other language :-).
+
+## Unpacking ! It's the ability to "extract" arrays and keys. It'll work in `my`s and parameters.
+my ($a, $b) = 1, 2;
+say $a; #=> 1
+my ($, $, $c) = 1, 2, 3; # keep the non-interesting anonymous
+say $c; #=> 3
+
+my ($head, *@tail) = 1, 2, 3; # Yes, it's the same as with "slurpy subs"
+my (*@small) = 1;
+
+sub foo(@array [$fst, $snd]) {
+ say "My first is $fst, my second is $snd ! All in all, I'm @array[].";
+ # (^ remember the `[]` to interpolate the array)
+}
+foo(@tail); #=> My first is 2, my second is 3 ! All in all, I'm 1 2
+
+
+# If you're not using the array itself, you can also keep it anonymous, much like a scalar:
+sub first-of-array(@ [$fst]) { $fst }
+first-of-array(@small); #=> 1
+first-of-array(@tail); # errors with "Too many positional parameters passed" (the array is too big)
+
+# You can also use a slurp ...
+sub slurp-in-array(@ [$fst, *@rest]) { # you could decide to keep `*@rest` anonymous
+ say $fst + @rest.elems;
+}
+slurp-in-array(@tail); #=> 3
+
+# You could even extract on a slurpy (but it's pretty useless ;-).)
+sub fst(*@ [$fst]) { # or simply : `sub fst($fst) { ... }`
+ say $fst;
+}
+fst(1); #=> 1
+fst(1, 2); # errors with "Too many positional parameters passed"
+
+# You can also destructure hashes (and classes, which you'll learn about later !)
+# The syntax is basically `%hash-name (:key($variable-to-store-value-in))`.
+# The hash can stay anonymous if you only need the values you extracted.
+sub key-of(% (:value($val), :qua($qua))) {
+ say "Got val $val, $qua times.";
+}
+
+# Then call it with a hash: (you need to keep the brackets for it to be a hash)
+key-of({value => 1});
+#key-of(%hash); # the same (for an equivalent `%hash`)
+
+## The last expression of a sub is returned automatically (though you may use the `return` keyword, of course):
+sub next-index($n) {
+ $n + 1;
+}
+my $new-n = next-index(3); # $new-n is now 4
+# This is true for everything, except for the looping constructs (due to performance reasons):
+# there's no purpose in building a list if we're just going to discard all the results.
+# If you still want to build one, you can use the `do` prefix: (or the `gather` prefix, which we'll see later)
+sub list-of($n) {
+ do for ^$n { # note the use of the range-to prefix operator `^` (`0..^N`)
+ $_ # current loop iteration
+ }
+}
+my @list3 = list-of(3); #=> (0, 1, 2)
+
+## You can create a lambda with `-> {}` ("pointy block") or `{}` ("block")
+my &lambda = -> $argument { "The argument passed to this lambda is $argument" }
+# `-> {}` and `{}` are pretty much the same thing, except that the former can take arguments,
+# and that the latter can be mistaken as a hash by the parser.
+
+# We can, for example, add 3 to each value of an array using map:
+my @arrayplus3 = map({ $_ + 3 }, @array); # $_ is the implicit argument
+
+# a sub (`sub {}`) has different semantics than a block (`{}` or `-> {}`):
+# a block doesn't have a "function context" (though it can have arguments), which means that if you
+# return from it, you're going to return from the parent function, compare:
+sub is-in(@array, $elem) {
+ # this will `return` out of the `is-in` sub
+ # once the condition evaluated to True, the loop won't be run anymore
+ map({ return True if $_ == $elem }, @array);
+}
+sub truthy-array(@array) {
+ # this will produce an array of `True` and `False`:
+ # (you can also say `anon sub` for "anonymous subroutine")
+ map(sub { if $_ { return True } else { return False } }, @array);
+ # ^ the `return` only returns from the anonymous `sub`
+}
+
+# You can also use the "whatever star" to create an anonymous function
+# (it'll stop at the furthest operator in the current expression)
+my @arrayplus3 = map(*+3, @array); # `*+3` is the same as `{ $_ + 3 }`
+my @arrayplus3 = map(*+*+3, @array); # also works. Same as `-> $a, $b { $a + $b + 3 }`
+say (*/2)(4); #=> 2
+ # Immediatly execute the function Whatever created.
+say ((*+3)/5)(5); #=> 1.6
+ # works even in parens !
+
+# but if you need to have more than one argument (`$_`) in a block (without wanting to resort to `-> {}`),
+# you can also use the implicit argument syntax, `$^` :
+map({ $^a + $^b + 3 }, @array); # same as the above
+
+# Note : those are sorted lexicographically. `{ $^b / $^a }` is like `-> $a, b { $b / $a }`
+
+## Multiple Dispatch
+# Perl 6 can decide which variant of a `sub` to call based on the type of the arguments,
+# or on arbitrary preconditions, like with a type or a `where`:
+
+# with types
+multi sub sayit(Int $n) { # note the `multi` keyword here
+ say "Number: $n";
+}
+multi sayit(Str $s) } # the `sub` is the default
+ say "String: $s";
+}
+sayit("foo"); # prints "String: foo"
+sayit(True); # fails at *compile time* with "calling 'sayit' will never work with arguments of types ..."
+
+# with arbitrary precondition:
+multi is-big(Int $n where * > 50) { "Yes !" } # using a closure
+multi is-big(Int $ where 10..50) { "Quite." } # this uses smart-matching (could use a regexp, etc)
+multi is-big(Int $) { "No" }
+
+# you can also name these checks, by creating "subsets":
+subset Even of Int where * %% 2;
+
+multi odd-or-even(Even) { "Even" } # the main case using the type. We don't name the argument
+multi odd-or-even($) { "Odd" } # "else"
+
+# You can even dispatch based on a positional's argument presence !
+multi with-or-without-you(:$with!) { # make it mandatory to be able to dispatch against it
+ say "I can live ! Actually, I can't.";
+}
+multi with-or-without-you {
+ say "Definitely can't live.";
+}
+# This is very, very useful for many purposes, like `MAIN` subs (covered later),
+# and even the language itself is using it in several places.
+# `is`, for example, is actually a `multi sub` named `trait_mod:<is>`, and it works off that.
+# `is rw`, for example, is a dispatch to a function with this signature:
+# sub trait_mod:<is>(Routine $r, :$rw!) {}
+# (commented because running this would probably lead to some very surprising side-effects !)
+
+
+### Scoping
+# In Perl 6, contrarily to many scripting languages (Python, Ruby, PHP, for example),
+# you are to declare your variables before using them. You already saw it, with `my`.
+# (there are other declarator keywords, like `our`, `has` and `state`, but we'll talk about them later)
+# This is called "lexical scoping", where in inner blocks, you can access variables from outer blocks.
+my $foo = 'Foo';
+sub foo {
+ my $bar = 'Bar';
+ sub bar {
+ say "$foo $bar";
+ }
+ &bar; # return the function
+}
+foo()(); #=> 'Foo Bar'
+
+# As you can see, `$foo` and `$bar` were captured.
+# But if we were to try and use `$bar` outside of `foo`, the variable would be undefined.
+# (and you'd get a compile time error)
+
+# Perl 6 has another kind of scope : dynamic scope.
+# They use the twigil (composed sigil) `*` to mark dynamically-scoped variables:
+my $*a = 1;
+# Dyamically-scoped variables depend on the current call stack, instead of the current block stack.
+sub foo {
+ my $*foo = 1;
+ bar(); # call `bar` in-place
+}
+sub bar {
+ say $*foo; # Perl 6 will look into the call stack instead, and find `foo`'s `$*a`,
+ # even though the blocks aren't nested (they're call-nested).
+ #=> 1
+}
+
+### Object Model
+
+## Perl 6 has a quite comprehensive object model
+## You declare a class with the keyword `class`, fields with `has`, methods with `method`.
+## In Perl 6, every field is private, and named `$!attr`, but if you declare it with `$.`,
+## you get a public (immutable) accessor along with it.
+
+# (Perl 6's object model ("SixModel") is very flexible, and allows you to dynamically add methods,
+# change semantics, etc -- This will not be covered here, and you should refer to the Synopsis)
+
+class A {
+ has $.field; # `$.field` is immutable. Use `$!field` from inside the class to modify it.
+ has $.other-field is rw; # You can, however, mark a public field as being read/write.
+ has Int $!private-field = 10;
+
+ method get-value {
+ $.field + $!private-field + $n;
+ }
+
+ method set-value($n) {
+ # $.field = $n; # As stated before, you can't use the `$.` immutable version.
+ $!field = $n; # This works, because `$!` is always mutable.
+
+ $.other-field = 5; # This works, because `$.other-field` was declared `rw` (mutable).
+ }
+
+ method !private-method {
+ say "This method is private to the class !";
+ }
+};
+
+# Create a new instance of A with $.field set to 5 :
+# note : you can't set private-field from here (more later on)
+my $a = A.new(field => 5);
+$a.get-value; #=> 18
+#$a.field = 5; # This fails, because the `has $.field` is immutable
+$a.other-field = 10; # This, however, works, because the public field is mutable (`rw`).
+
+## Perl 6 also has inheritance (along with multiple inheritance ... Considered a misfeature by many)
+
+class A {
+ has $.val;
+
+ submethod not-inherited {
+ say "This method won't be available on B.";
+ say "This is most useful for BUILD, which we'll see later";
+ }
+
+ method bar { $.val * 5 }
+}
+class B is A { # inheritance uses `is`
+ method foo {
+ say $.val;
+ }
+
+ method bar { $.val * 10 } # this shadows A's `bar`
+}
+
+my B $b .= new(val => 5); # When you use `my T $var`, `$var` starts off with `T` itself in it,
+ # so you can call `new` on it.
+ # (`.=` is just the compound operator composed of the dot-call and of the assignment operator
+ # `$a .= b` is the same as `$a = $a.b`)
+ # Also note that `BUILD` (the method called inside `new`) will set parent properties too,
+ # so you can pass `val => 5`
+# $b.not-inherited; # This won't work, for reasons explained above
+$b.foo; # prints 5
+$b.bar; #=> 50, since it calls B's `bar`
+
+## Roles are supported too (also called Mixins in other languages)
+role PrintableVal {
+ has $!counter = 0;
+ method print {
+ say $.val;
+ }
+}
+
+# you "use" a mixin with "does" :
+class Item does PrintableVal {
+ has $.val;
+
+ # When `does`-ed, a `role` literally "mixes in" the class :
+ # the methods and fields are put together, which means a class can access
+ # the private fields/methods of its roles (but not the inverse !) :
+ method access {
+ say $!counter++;
+ }
+
+ # However, this :
+ # method print {}
+ # is an error, since the compiler wouldn't know which `print` to use :
+ # contrarily to inheritance, methods mixed in can't be shadowed - they're put at the same "level"
+
+ # NOTE : You can use a role as a class (with `is ROLE`). In this case, methods will be shadowed,
+ # since the compiler will consider `ROLE` to be a class
+}
+
+### Exceptions
+# Exceptions are built on top of classes, usually in the package `X` (like `X::IO`).
+# Unlike many other languages, in Perl 6, you put the `CATCH` block *within* the block to `try`.
+# By default, a `try` has a `CATCH` block that catches any exception (`CATCH { default {} }`).
+# You can redefine it using `when`s (and `default`) to handle the exceptions you want:
+try {
+ open 'foo';
+ CATCH {
+ when X::AdHoc { say "unable to open file !" }
+ # any other exception will be re-raised, since we don't have a `default`
+ }
+}
+
+# You can throw an exception using `die`:
+die X::AdHoc.new(payload => 'Error !');
+# TODO warn
+# TODO fail
+# TODO CONTROL
+
+### Packages
+# Packages are a way to reuse code. Packages are like "namespaces", and any element of the six model
+# (`module`, `role`, `class`, `grammar`, `subset` and `enum`) are actually packages.
+# (you can say that packages are the lowest common denomitor between them)
+# Packages play a big part in a language, as Perl is well-known for CPAN,
+# the Comprehensive Perl Archive Network.
+# You usually don't use packages directly : you use `class Package::Name::Here;`, or if you
+# only want to export variables/subs, you can use `module`:
+module Hello::World { # bracketed form
+ # if `Hello` doesn't exist yet, it'll just be created as an "empty package stub"
+ # that can be redeclared as something else later.
+ # declarations here
+}
+module Parse::Text; # file-scoped form
+grammar Parse::Text::Grammar { # A grammar is a fine package, which you could `use`
+}
+
+# NOTE for Perl 5 users: even though the `package` keyword exists,
+# the braceless form is invalid (to catch a "perl5ism"). This will error out:
+# package Foo; # because Perl 6 will think the entire file is Perl 5
+# Just use `module` or the brace version of `package`.
+
+# You can use a module (bring its declarations into scope) with `use`
+use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module
+say from-json('[1]').perl; #=> [1]
+
+# As said before, any part of the six model is also a package.
+# Since `JSON::Tiny` uses (its own) `JSON::Tiny::Actions` class, you can use it:
+my $actions = JSON::Tiny::Actions.new;
+
+# We'll see how to export variables and subs in the next part:
+
+### Declarators
+# In Perl 6, you get different behaviors based on how you declare a variable.
+# You've already seen `my` and `has`, we'll now explore the others.
+
+## * `our` (happens at `INIT` time -- see "Phasers" below)
+# Along with `my`, there are several others declarators you can use.
+# The first one you'll want for the previous part is `our`.
+# (All packagish things (`class`, `role`, etc) are `our` by default)
+# it's like `my`, but it also creates a package variable:
+module Foo::Bar {
+ our $n = 1; # note: you can't put a type constraint on an `our` variable
+ our sub inc {
+ our sub available { # if you try to make scoped `sub`s `our` ... Better know what you're doing (Don't !).
+ say "Don't do that. Seriously. You'd get burned.";
+ }
+ my sub unavailable { # `my sub` is the default
+ say "Can't access me from outside, I'm my !";
+ }
+ }
+
+ say ++$n; # lexically-scoped variables are still available
+}
+say $Foo::Bar::n; #=> 1
+Foo::Bar::inc; #=> 2
+Foo::Bar::inc; #=> 3
+
+## * `constant` (happens at `BEGIN` time)
+# You can use the `constant` keyword to declare a compile-time variable/symbol:
+constant Pi = 3.14;
+constant $var = 1;
+
+## * `state` (happens at run time, but only once)
+# State variables are only executed one time
+# (they exist in other langages such as C as `static`)
+sub fixed-rand {
+ state $val = rand;
+ say $rand;
+}
+fixed-rand for ^10; # will print the same number 10 times
+
+# Note, however, that they exist separately in different enclosing contexts.
+# If you declare a function with a `state` within a loop, it'll re-create the variable
+# for each iteration of loop. See:
+for ^5 -> $a {
+ sub foo {
+ state $val = rand; # This will be a different value for every value of `$a`
+ }
+ for ^5 -> $b {
+ say foo; # This will print the same value 5 times, but only 5. Next iteration will re-run `rand`
+ }
+}
+
+
+
+### Phasers
+# Phasers in Perl 6 are blocks that happen at determined points of time in your program
+# When the program is compiled, when a for loop runs, when you leave a block, when
+# an exception gets thrown ... (`CATCH` is actually a phaser !)
+# Some of them can be used for their return values, some of them can't
+# (those that can have a "[*]" in the beginning of their explanation text).
+# Let's have a look !
+
+## * Compile-time phasers
+BEGIN { say "[*] Runs at compile time, as soon as possible, only once" }
+CHECK { say "[*] Runs at compile time, instead as late as possible, only once" }
+
+## * Run-time phasers
+INIT { say "[*] Runs at run time, as soon as possible, only once" }
+END { say "Runs at run time, as late as possible, only once" }
+
+## * Block phasers
+ENTER { say "[*] Runs everytime you enter a block, repeats on loop blocks" }
+LEAVE { say "Runs everytime you leave a block, even when an exception happened. Repeats on loop blocks." }
+
+PRE { say "Asserts a precondition at every block entry, before ENTER (especially useful for loops)" }
+POST { say "Asserts a postcondition at every block exit, after LEAVE (especially useful for loops)" }
+
+## * Block/exceptions phasers
+sub {
+ KEEP { say "Runs when you exit a block successfully (without throwing an exception)" }
+ UNDO { say "Runs when you exit a block unsuccessfully (by throwing an exception)" }
+}
+
+## * Loop phasers
+for ^5 {
+ FIRST { say "[*] The first time the loop is run, before ENTER" }
+ NEXT { say "At loop continuation time, before LEAVE" }
+ LAST { say "At loop termination time, after LEAVE" }
+}
+
+## * Role/class phasers
+COMPOSE { "When a role is composed into a class. /!\ NOT YET IMPLEMENTED" }
+
+# They allow for cute trick or clever code ...:
+say "This code took " ~ (time - CHECK time) ~ "s to run";
+
+# ... or clever organization:
+sub do-db-stuff {
+ ENTER $db.start-transaction; # create a new transaction everytime we enter the sub
+ KEEP $db.commit; # commit the transaction if all went well
+ UNDO $db.rollback; # or rollback if all hell broke loose
+}
+
+
+### More operators thingies !
+
+## Everybody loves operators ! Let's get more of them
+
+## The precedence list can be found here : http://perlcabal.org/syn/S03.html#Operator_precedence
+## But first, we need a little explanation about associativity :
+
+# - Binary operators:
+$a ! $b ! $c; # with a left-associative `!`, this is `($a ! $b) ! $c`
+$a ! $b ! $c; # with a right-associative `!`, this is `$a ! ($b ! $c)`
+$a ! $b ! $c; # with a non-associative `!`, this is illegal
+$a ! $b ! $c; # with a chain-associative `!`, this is `($a ! $b) and ($b ! $c)`
+$a ! $b ! $c; # with a list-associative `!`, this is `infix:<>`
+
+# - Unary operators:
+!$a! # with left-associative `!`, this is `(!$a)!`
+!$a! # with right-associative `!`, this is `!($a!)`
+!$a! # with non-associative `!`, this is illegal
+
+## Create your own operators !
+# Okay, you've been reading all of that, so I guess I should try to show you something exciting.
+# I'll tell you a little secret (actually not):
+# In Perl 6, all operators are actually just funny-looking subroutines.
+
+# You can declare an operator just like you declare a sub:
+sub prefix:<win>($winner) { # refer to the operator categories
+ # (yes, it's the "words operator" `<>`)
+ say "$winner Won !";
+}
+win "The King"; #=> The King Won !
+ # (prefix is before)
+
+# you can still call the sub with its "full name"
+say prefix:<!>(True); #=> False
+
+sub postfix:<!>(Int $n) {
+ [*] 2..$n; # using the reduce meta-operator ... See below ;-) !
+}
+say 5!; #=> 120
+ # (postfix is after)
+
+
+sub infix:<times>(Int $n, Block $r) { # infix in the middle
+ for ^$n {
+ $r(); # needs the parentheses because it's a scalar
+ }
+}
+3 times -> { say "hello" }; #=> hello
+ #=> hello
+ #=> hello
+
+# For circumfix and post-circumfix ones
+sub circumfix:<[ ]>(Int $n) {
+ $n ** $n
+}
+say [5]; #=> 3125
+ # circumfix is around
+
+sub postcircumfix:<{ }>(Str $s, Int $idx) { # post-circumfix is "after a term, around something"
+ $s.substr($idx, 1);
+}
+say "abc"{1}; #=> b
+ # after the term `"abc"`, and around the index (1)
+
+# This really means a lot -- because everything in Perl 6 uses this.
+# For example, to delete a key from a hash, you use the `:delete` adverb (named argument)
+%h{$key}:delete;
+# equivalent to:
+postcircumfix:<{ }>(%h, $key, :delete);
+# It's *all* using the same building blocks! Syntactic categories (prefix infix ...),
+# named arguments (adverbs), ..., used to build the language are available to you.
+
+# (you are, obviously, recommended against making an operator out of *everything* --
+# with great power comes great responsibility)
+
+## Meta operators !
+# Oh boy, get ready. Get ready, because we're dwelving deep into the rabbit's hole,
+# and you probably won't want to go back to other languages after reading that.
+# (I'm guessing you don't want to already at that point).
+
+# - Reduce meta-operator
+
+## End of the operator list:
+
+
+## Sequence operator
+# The sequence operator is one of Perl 6's most powerful features:
+# it's composed of first, on the left, the list you want Perl 6 to deduce from (and might include a closure),
+# and on the right, a value or the predicate for when to stop, or even Whatever for a lazy infinite list.
+my @list = 1, 2, 3 ... 10; # basic deducing
+#my @list = 1, 3, 6 ... 10; # this throws you into an infinite loop, because Perl 6 can't figure out the end
+my @list = 1, 2, 3 ...^ 10; # as with ranges, you can exclude the last element (when the predicate matches)
+my @list = 1, 3, 9 ... * > 30; # you can use a predicate (with the Whatever Star, here)
+my @list = 1, 3, 9 ... { $_ > 30 }; # (equivalent to the above)
+my @fib = 1, 1, *+* ... *; # lazy infinite list of prime numbers, computed using a closure !
+my @fib = 1, 1, -> $a, $b { $a + $b } ... *; # (equivalent to the above)
+say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
+ # (using a range as the index)
+# Note : as for ranges, once reified, elements aren't re-calculated.
+# That's why `@primes[^100]` will take a long time the first time you print it, then be instant
+
+
+## * Sort comparison
+# They return one value of the `Order` enum : `Less`, `Same` and `More` (which numerify to -1, 0 or +1).
+1 <=> 4; # sort comparison for numerics
+'a' leg 'b'; # sort comparison for string
+$obj eqv $obj2; # sort comparison using eqv semantics
+
+## * Generic ordering
+3 before 4; # True
+'b' after 'a'; # True
+
+## * Short-circuit default operator
+# Like `or` and `||`, but instead returns the first *defined* value :
+say Any // Nil // 0 // 5; #=> 5
+
+## * Short-circuit exclusive or (XOR)
+# Returns `True` if one (and only one) of its arguments is true
+say True ^^ False; #=> True
+
+## * Flip Flop
+# The flip flop operators (`ff` and `fff`, equivalent to Perl 5/Ruby's `..` and `...`).
+# are operators that take two predicates to test:
+# They are `False` until their left side returns `True`, then are `True` until their right side returns `True`.
+# Like for ranges, you can exclude the iteration when it became `True`/`False` by using `^` on either side.
+# Let's start with an example :
+for <well met young hero we shall meet later> {
+ # by default, `ff`/`fff` smart-match (`~~`) against `$_`:
+ if 'met' ^ff 'meet' { # won't enter the if for "met" (explained in details below).
+ .say
+ }
+
+ if rand == 0 ff rand == 1 { # compare variables other than `$_`
+ say "This ... probably will never run ...";
+ }
+}
+# This will print "young hero we shall meet" (excluding "met"):
+# the flip-flop will start returning `True` when it first encounters "met"
+# (but will still return `False` for "met" itself, due to the leading `^` on `ff`),
+# until it sees "meet", which is when it'll start returning `False`.
+
+# The difference between `ff` (flip-flop) and `fff` (flip-flop) is that
+# `ff` will test its right side just as its left side changes to `True`,
+# and can get back to `False` right away (*except* it'll be `True` for the iteration that matched)
+# while `fff` will wait for the next iteration to try its right side, once its left side changed:
+.say if 'B' ff 'B' for <A B C B A>; #=> B B
+ # because the right-hand-side was tested directly (and returned `True`).
+ # "B"s are still printed since it matched that time
+ # (it just went back to `False` right away)
+.say if 'B' fff 'B' for <A B C B A>; #=> B C B
+ # because the right-hand-side wasn't tested until `$_` became "C"
+ # (and thus did not match directly).
+
+# A flip-flop can change state as many times as needed:
+for <test start print this stop you stopped printing start printing again stop not anymore> {
+ .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # exclude both "start" and "stop",
+ #=> "print this printing again"
+}
+
+# you might also use a Whatever Star,
+# which is equivalent to `True` for the left side or `False` for the right:
+for (1, 3, 60, 3, 40, 60) {
+ .say if $_ > 50 ff *; # Once the flip-flop reached a number greater than 50, it'll never go back to `False`
+ #=> 60 3 40 60
+}
+
+# You can also use this property to create an `If` that'll not execute the first time :
+for <a b c> {
+ .say if * ^ff *; # the flip-flop is `True` and never goes back to `False`,
+ # but the `^` makes it *not run* on the first iteration
+ #=> b c
+}
+```
diff --git a/zh-cn/julia-cn.html.markdown b/zh-cn/julia-cn.html.markdown
new file mode 100644
index 00000000..b7239786
--- /dev/null
+++ b/zh-cn/julia-cn.html.markdown
@@ -0,0 +1,729 @@
+---
+language: julia
+filename: learn-julia-zh.jl
+contributors:
+ - ["Jichao Ouyang", "http://oyanglul.us"]
+translators:
+ - ["Jichao Ouyang"]
+lang: zh-cn
+---
+
+```julia
+# 单行注释只需要一个井号
+#= 多行注释
+ 只需要以 '#=' 开始 '=#' 结束
+ 还可以嵌套.
+=#
+
+####################################################
+## 1. 原始类型与操作符
+####################################################
+
+# Julia 中一切皆是表达式。
+
+# 这是一些基本数字类型.
+3 # => 3 (Int64)
+3.2 # => 3.2 (Float64)
+2 + 1im # => 2 + 1im (Complex{Int64})
+2//3 # => 2//3 (Rational{Int64})
+
+# 支持所有的普通中缀操作符。
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+35 / 5 # => 7.0
+5 / 2 # => 2.5 # 用 Int 除 Int 永远返回 Float
+div(5, 2) # => 2 # 使用 div 截断小数点
+5 \ 35 # => 7.0
+2 ^ 2 # => 4 # 次方, 不是二进制 xor
+12 % 10 # => 2
+
+# 用括号提高优先级
+(1 + 3) * 2 # => 8
+
+# 二进制操作符
+~2 # => -3 # 非
+3 & 5 # => 1 # 与
+2 | 4 # => 6 # 或
+2 $ 4 # => 6 # 异或
+2 >>> 1 # => 1 # 逻辑右移
+2 >> 1 # => 1 # 算术右移
+2 << 1 # => 4 # 逻辑/算术 右移
+
+# 可以用函数 bits 查看二进制数。
+bits(12345)
+# => "0000000000000000000000000000000000000000000000000011000000111001"
+bits(12345.0)
+# => "0100000011001000000111001000000000000000000000000000000000000000"
+
+# 布尔值是原始类型
+true
+false
+
+# 布尔操作符
+!true # => false
+!false # => true
+1 == 1 # => true
+2 == 1 # => false
+1 != 1 # => false
+2 != 1 # => true
+1 < 10 # => true
+1 > 10 # => false
+2 <= 2 # => true
+2 >= 2 # => true
+# 比较可以串联
+1 < 2 < 3 # => true
+2 < 3 < 2 # => false
+
+# 字符串可以由 " 创建
+"This is a string."
+
+# 字符字面量可用 ' 创建
+'a'
+
+# 可以像取数组取值一样用 index 取出对应字符
+"This is a string"[1] # => 'T' # Julia 的 index 从 1 开始 :(
+# 但是对 UTF-8 无效,
+# 因此建议使用遍历器 (map, for loops, 等).
+
+# $ 可用于字符插值:
+"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
+# 可以将任何 Julia 表达式放入括号。
+
+# 另一种格式化字符串的方式是 printf 宏.
+@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000
+
+# 打印字符串很容易
+println("I'm Julia. Nice to meet you!")
+
+####################################################
+## 2. 变量与集合
+####################################################
+
+# 给变量赋值就是声明变量
+some_var = 5 # => 5
+some_var # => 5
+
+# 访问未声明变量会抛出异常
+try
+ some_other_var # => ERROR: some_other_var not defined
+catch e
+ println(e)
+end
+
+# 变量名需要以字母开头.
+# 之后任何字母,数字,下划线,叹号都是合法的。
+SomeOtherVar123! = 6 # => 6
+
+# 甚至可以用 unicode 字符
+☃ = 8 # => 8
+# 用数学符号非常方便
+2 * π # => 6.283185307179586
+
+# 注意 Julia 的命名规约:
+#
+# * 变量名为小写,单词之间以下划线连接('\_')。
+#
+# * 类型名以大写字母开头,单词以 CamelCase 方式连接。
+#
+# * 函数与宏的名字小写,无下划线。
+#
+# * 会改变输入的函数名末位为 !。
+# 这类函数有时被称为 mutating functions 或 in-place functions.
+
+# 数组存储一列值,index 从 1 开始。
+a = Int64[] # => 0-element Int64 Array
+
+# 一维数组可以以逗号分隔值的方式声明。
+b = [4, 5, 6] # => 包含 3 个 Int64 类型元素的数组: [4, 5, 6]
+b[1] # => 4
+b[end] # => 6
+
+# 二维数组以分号分隔维度。
+matrix = [1 2; 3 4] # => 2x2 Int64 数组: [1 2; 3 4]
+
+# 使用 push! 和 append! 往数组末尾添加元素
+push!(a,1) # => [1]
+push!(a,2) # => [1,2]
+push!(a,4) # => [1,2,4]
+push!(a,3) # => [1,2,4,3]
+append!(a,b) # => [1,2,4,3,4,5,6]
+
+# 用 pop 弹出末尾元素
+pop!(b) # => 6 and b is now [4,5]
+
+# 可以再放回去
+push!(b,6) # b 又变成了 [4,5,6].
+
+a[1] # => 1 # 永远记住 Julia 的 index 从 1 开始!
+
+# 用 end 可以直接取到最后索引. 可用作任何索引表达式
+a[end] # => 6
+
+# 还支持 shift 和 unshift
+shift!(a) # => 返回 1,而 a 现在时 [2,4,3,4,5,6]
+unshift!(a,7) # => [7,2,4,3,4,5,6]
+
+# 以叹号结尾的函数名表示它会改变参数的值
+arr = [5,4,6] # => 包含三个 Int64 元素的数组: [5,4,6]
+sort(arr) # => [4,5,6]; arr 还是 [5,4,6]
+sort!(arr) # => [4,5,6]; arr 现在是 [4,5,6]
+
+# 越界会抛出 BoundsError 异常
+try
+ a[0] # => ERROR: BoundsError() in getindex at array.jl:270
+ a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
+catch e
+ println(e)
+end
+
+# 错误会指出发生的行号,包括标准库
+# 如果你有 Julia 源代码,你可以找到这些地方
+
+# 可以用 range 初始化数组
+a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
+
+# 可以切割数组
+a[1:3] # => [1, 2, 3]
+a[2:end] # => [2, 3, 4, 5]
+
+# 用 splice! 切割原数组
+arr = [3,4,5]
+splice!(arr,2) # => 4 ; arr 变成了 [3,5]
+
+# 用 append! 连接数组
+b = [1,2,3]
+append!(a,b) # a 变成了 [1, 2, 3, 4, 5, 1, 2, 3]
+
+# 检查元素是否在数组中
+in(1, a) # => true
+
+# 用 length 获得数组长度
+length(a) # => 8
+
+# Tuples 是 immutable 的
+tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple.
+tup[1] # => 1
+try:
+ tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
+catch e
+ println(e)
+end
+
+# 大多数组的函数同样支持 tuples
+length(tup) # => 3
+tup[1:2] # => (1,2)
+in(2, tup) # => true
+
+# 可以将 tuples 元素分别赋给变量
+a, b, c = (1, 2, 3) # => (1,2,3) # a is now 1, b is now 2 and c is now 3
+
+# 不用括号也可以
+d, e, f = 4, 5, 6 # => (4,5,6)
+
+# 单元素 tuple 不等于其元素值
+(1,) == 1 # => false
+(1) == 1 # => true
+
+# 交换值
+e, d = d, e # => (5,4) # d is now 5 and e is now 4
+
+
+# 字典Dictionaries store mappings
+empty_dict = Dict() # => Dict{Any,Any}()
+
+# 也可以用字面量创建字典
+filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
+# => Dict{ASCIIString,Int64}
+
+# 用 [] 获得键值
+filled_dict["one"] # => 1
+
+# 获得所有键
+keys(filled_dict)
+# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# 注意,键的顺序不是插入时的顺序
+
+# 获得所有值
+values(filled_dict)
+# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# 注意,值的顺序也一样
+
+# 用 in 检查键值是否已存在,用 haskey 检查键是否存在
+in(("one", 1), filled_dict) # => true
+in(("two", 3), filled_dict) # => false
+haskey(filled_dict, "one") # => true
+haskey(filled_dict, 1) # => false
+
+# 获取不存在的键的值会抛出异常
+try
+ filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+catch e
+ println(e)
+end
+
+# 使用 get 可以提供默认值来避免异常
+# get(dictionary,key,default_value)
+get(filled_dict,"one",4) # => 1
+get(filled_dict,"four",4) # => 4
+
+# 用 Sets 表示无序不可重复的值的集合
+empty_set = Set() # => Set{Any}()
+# 初始化一个 Set 并定义其值
+filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+
+# 添加值
+push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
+
+# 检查是否存在某值
+in(2, filled_set) # => true
+in(10, filled_set) # => false
+
+# 交集,并集,差集
+other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
+intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
+union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
+setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
+
+
+####################################################
+## 3. 控制流
+####################################################
+
+# 声明一个变量
+some_var = 5
+
+# 这是一个 if 语句,缩进不是必要的
+if some_var > 10
+ println("some_var is totally bigger than 10.")
+elseif some_var < 10 # elseif 是可选的.
+ println("some_var is smaller than 10.")
+else # else 也是可选的.
+ println("some_var is indeed 10.")
+end
+# => prints "some var is smaller than 10"
+
+
+# For 循环遍历
+# Iterable 类型包括 Range, Array, Set, Dict, 以及 String.
+for animal=["dog", "cat", "mouse"]
+ println("$animal is a mammal")
+ # 可用 $ 将 variables 或 expression 转换为字符串into strings
+end
+# prints:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
+
+# You can use 'in' instead of '='.
+for animal in ["dog", "cat", "mouse"]
+ println("$animal is a mammal")
+end
+# prints:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
+
+for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+ println("$(a[1]) is a $(a[2])")
+end
+# prints:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
+
+for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+ println("$k is a $v")
+end
+# prints:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
+
+# While 循环
+x = 0
+while x < 4
+ println(x)
+ x += 1 # x = x + 1
+end
+# prints:
+# 0
+# 1
+# 2
+# 3
+
+# 用 try/catch 处理异常
+try
+ error("help")
+catch e
+ println("caught it $e")
+end
+# => caught it ErrorException("help")
+
+
+####################################################
+## 4. 函数
+####################################################
+
+# 用关键字 'function' 可创建一个新函数
+#function name(arglist)
+# body...
+#end
+function add(x, y)
+ println("x is $x and y is $y")
+
+ # 最后一行语句的值为返回
+ x + y
+end
+
+add(5, 6) # => 在 "x is 5 and y is 6" 后会打印 11
+
+# 还可以定义接收可变长参数的函数
+function varargs(args...)
+ return args
+ # 关键字 return 可在函数内部任何地方返回
+end
+# => varargs (generic function with 1 method)
+
+varargs(1,2,3) # => (1,2,3)
+
+# 省略号 ... 被称为 splat.
+# 刚刚用在了函数定义中
+# 还可以用在函数的调用
+# Array 或者 Tuple 的内容会变成参数列表
+Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # 获得一个 Array 的 Set
+Set([1,2,3]...) # => Set{Int64}(1,2,3) # 相当于 Set(1,2,3)
+
+x = (1,2,3) # => (1,2,3)
+Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # 一个 Tuple 的 Set
+Set(x...) # => Set{Int64}(2,3,1)
+
+
+# 可定义可选参数的函数
+function defaults(a,b,x=5,y=6)
+ return "$a $b and $x $y"
+end
+
+defaults('h','g') # => "h g and 5 6"
+defaults('h','g','j') # => "h g and j 6"
+defaults('h','g','j','k') # => "h g and j k"
+try
+ defaults('h') # => ERROR: no method defaults(Char,)
+ defaults() # => ERROR: no methods defaults()
+catch e
+ println(e)
+end
+
+# 还可以定义键值对的参数
+function keyword_args(;k1=4,name2="hello") # note the ;
+ return ["k1"=>k1,"name2"=>name2]
+end
+
+keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
+keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
+keyword_args() # => ["name2"=>"hello","k1"=>4]
+
+# 可以组合各种类型的参数在同一个函数的参数列表中
+function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
+ println("normal arg: $normal_arg")
+ println("optional arg: $optional_positional_arg")
+ println("keyword arg: $keyword_arg")
+end
+
+all_the_args(1, 3, keyword_arg=4)
+# prints:
+# normal arg: 1
+# optional arg: 3
+# keyword arg: 4
+
+# Julia 有一等函数
+function create_adder(x)
+ adder = function (y)
+ return x + y
+ end
+ return adder
+end
+
+# 这是用 "stabby lambda syntax" 创建的匿名函数
+(x -> x > 2)(3) # => true
+
+# 这个函数和上面的 create_adder 一模一样
+function create_adder(x)
+ y -> x + y
+end
+
+# 你也可以给内部函数起个名字
+function create_adder(x)
+ function adder(y)
+ x + y
+ end
+ adder
+end
+
+add_10 = create_adder(10)
+add_10(3) # => 13
+
+
+# 内置的高阶函数有
+map(add_10, [1,2,3]) # => [11, 12, 13]
+filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# 还可以使用 list comprehensions 替代 map
+[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
+[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+
+####################################################
+## 5. 类型
+####################################################
+
+# Julia 有类型系统
+# 所有的值都有类型;但变量本身没有类型
+# 你可以用 `typeof` 函数获得值的类型
+typeof(5) # => Int64
+
+# 类型是一等值
+typeof(Int64) # => DataType
+typeof(DataType) # => DataType
+# DataType 是代表类型的类型,也代表他自己的类型
+
+# 类型可用作文档化,优化,以及调度
+# 并不是静态检查类型
+
+# 用户还可以自定义类型
+# 跟其他语言的 records 或 structs 一样
+# 用 `type` 关键字定义新的类型
+
+# type Name
+# field::OptionalType
+# ...
+# end
+type Tiger
+ taillength::Float64
+ coatcolor # 不附带类型标注的相当于 `::Any`
+end
+
+# 构造函数参数是类型的属性
+tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")
+
+# 用新类型作为构造函数还会创建一个类型
+sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
+
+# struct 类似的类型被称为具体类型
+# 他们可被实例化但不能有子类型
+# 另一种类型是抽象类型
+
+# abstract Name
+abstract Cat # just a name and point in the type hierarchy
+
+# 抽象类型不能被实例化,但是可以有子类型
+# 例如,Number 就是抽象类型
+subtypes(Number) # => 6-element Array{Any,1}:
+ # Complex{Float16}
+ # Complex{Float32}
+ # Complex{Float64}
+ # Complex{T<:Real}
+ # ImaginaryUnit
+ # Real
+subtypes(Cat) # => 0-element Array{Any,1}
+
+# 所有的类型都有父类型; 可以用函数 `super` 得到父类型.
+typeof(5) # => Int64
+super(Int64) # => Signed
+super(Signed) # => Real
+super(Real) # => Number
+super(Number) # => Any
+super(super(Signed)) # => Number
+super(Any) # => Any
+# 所有这些类型,除了 Int64, 都是抽象类型.
+
+# <: 是类型集成操作符
+type Lion <: Cat # Lion 是 Cat 的子类型
+ mane_color
+ roar::String
+end
+
+# 可以继续为你的类型定义构造函数
+# 只需要定义一个同名的函数
+# 并调用已有的构造函数设置一个固定参数
+Lion(roar::String) = Lion("green",roar)
+# 这是一个外部构造函数,因为他再类型定义之外
+
+type Panther <: Cat # Panther 也是 Cat 的子类型
+ eye_color
+ Panther() = new("green")
+ # Panthers 只有这个构造函数,没有默认构造函数
+end
+# 使用内置构造函数,如 Panther,可以让你控制
+# 如何构造类型的值
+# 应该尽可能使用外部构造函数而不是内部构造函数
+
+####################################################
+## 6. 多分派
+####################################################
+
+# 在Julia中, 所有的具名函数都是类属函数
+# 这意味着他们都是有很大小方法组成的
+# 每个 Lion 的构造函数都是类属函数 Lion 的方法
+
+# 我们来看一个非构造函数的例子
+
+# Lion, Panther, Tiger 的 meow 定义为
+function meow(animal::Lion)
+ animal.roar # 使用点符号访问属性
+end
+
+function meow(animal::Panther)
+ "grrr"
+end
+
+function meow(animal::Tiger)
+ "rawwwr"
+end
+
+# 试试 meow 函数
+meow(tigger) # => "rawwr"
+meow(Lion("brown","ROAAR")) # => "ROAAR"
+meow(Panther()) # => "grrr"
+
+# 再看看层次结构
+issubtype(Tiger,Cat) # => false
+issubtype(Lion,Cat) # => true
+issubtype(Panther,Cat) # => true
+
+# 定义一个接收 Cats 的函数
+function pet_cat(cat::Cat)
+ println("The cat says $(meow(cat))")
+end
+
+pet_cat(Lion("42")) # => prints "The cat says 42"
+try
+ pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
+catch e
+ println(e)
+end
+
+# 在面向对象语言中,通常都是单分派
+# 这意味着分派方法是通过第一个参数的类型决定的
+# 在Julia中, 所有参数类型都会被考虑到
+
+# 让我们定义有多个参数的函数,好看看区别
+function fight(t::Tiger,c::Cat)
+ println("The $(t.coatcolor) tiger wins!")
+end
+# => fight (generic function with 1 method)
+
+fight(tigger,Panther()) # => prints The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => prints The orange tiger wins!
+
+# 让我们修改一下传入具体为 Lion 类型时的行为
+fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
+# => fight (generic function with 2 methods)
+
+fight(tigger,Panther()) # => prints The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins!
+
+# 把 Tiger 去掉
+fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+# => fight (generic function with 3 methods)
+
+fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr
+try
+ fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
+catch
+end
+
+# 在试试让 Cat 在前面
+fight(c::Cat,l::Lion) = println("The cat beats the Lion")
+# => Warning: New definition
+# fight(Cat,Lion) at none:1
+# is ambiguous with
+# fight(Lion,Cat) at none:2.
+# Make sure
+# fight(Lion,Lion)
+# is defined first.
+#fight (generic function with 4 methods)
+
+# 警告说明了无法判断使用哪个 fight 方法
+fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr
+# 结果在老版本 Julia 中可能会不一样
+
+fight(l::Lion,l2::Lion) = println("The lions come to a tie")
+fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie
+
+
+# Under the hood
+# 你还可以看看 llvm 以及生成的汇编代码
+
+square_area(l) = l * l # square_area (generic function with 1 method)
+
+square_area(5) #25
+
+# 给 square_area 一个整形时发生什么
+code_native(square_area, (Int32,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1 # Prologue
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # movsxd RAX, EDI # Fetch l from memory?
+ # imul RAX, RAX # Square l and store the result in RAX
+ # pop RBP # Restore old base pointer
+ # ret # Result will still be in RAX
+
+code_native(square_area, (Float32,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # vmulss XMM0, XMM0, XMM0 # Scalar single precision multiply (AVX)
+ # pop RBP
+ # ret
+
+code_native(square_area, (Float64,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # vmulsd XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
+ # pop RBP
+ # ret
+ #
+# 注意 只要参数中又浮点类型,Julia 就使用浮点指令
+# 让我们计算一下圆的面积
+circle_area(r) = pi * r * r # circle_area (generic function with 1 method)
+circle_area(5) # 78.53981633974483
+
+code_native(circle_area, (Int32,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # Source line: 1
+ # vcvtsi2sd XMM0, XMM0, EDI # Load integer (r) from memory
+ # movabs RAX, 4593140240 # Load pi
+ # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r
+ # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r
+ # pop RBP
+ # ret
+ #
+
+code_native(circle_area, (Float64,))
+ # .section __TEXT,__text,regular,pure_instructions
+ # Filename: none
+ # Source line: 1
+ # push RBP
+ # mov RBP, RSP
+ # movabs RAX, 4593140496
+ # Source line: 1
+ # vmulsd XMM1, XMM0, QWORD PTR [RAX]
+ # vmulsd XMM0, XMM1, XMM0
+ # pop RBP
+ # ret
+ #
+```