diff options
| -rw-r--r-- | perl6.html.markdown | 1007 | ||||
| -rw-r--r-- | pt-br/markdown-pt.html.markdown | 251 | ||||
| -rw-r--r-- | zh-cn/julia-cn.html.markdown | 729 |
3 files changed, 1987 insertions, 0 deletions
diff --git a/perl6.html.markdown b/perl6.html.markdown new file mode 100644 index 00000000..b21cb1fa --- /dev/null +++ b/perl6.html.markdown @@ -0,0 +1,1007 @@ +--- +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` +# Before talking about `if`, we need to know which values are "Truthy" (represent True), +# and which are "Falsey" (or "Falsy") -- meaning they represent False. +# Only these values are Falsey: (), 0, "0", Nil, A type, and of course False itself. +# Every other value is Truthy. +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, +# and thanks to Perl 6's "topic variable", $_. +# This variable contains the default argument of a block, +# a loop's current iteration (unless explicitly named), etc. +# Given simply puts its argument into `$_` (like a block would do), +# and `when` uses it using the "smart matching" operator. +# Since other Perl 6 constructs use this variable (as said before, like `for`, blocks, etc), +# this means the powerful `when` is not only applicable along with a `given`, +# but instead anywhere a `$_` exists. +given "foo bar" { + when /foo/ { # you'll read about the smart-matching operator below -- just know `when` uses it + # this is equivalent to `if $_ ~~ /foo/` + 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 !"; +} + +# As we saw with given, for's default "current iteration" variable is `$_`. +# That means you can use `when` in a `for` just like you were in a when. +for @array { + say "I've got $_"; + + .say; # This is also allowed. + # A dot call with no "topic" (receiver) is sent to `$_` by default + $_.say; # the above and this are equivalent. +} + +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; # 4, which is Truthy. Calls `.Bool` on `4` and gets `True`. +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; + +# And because you're going to want them, you also have composed assignment operators: +$a *= 2; # multiply and assignment +$b %%= 5; # divisible by and assignment +$c .= say; # method call and assignment + +### 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 operators (after) have to come *directly* after the term. + # No whitespace. You can use parentheses to disambiguate, i.e. `(5!)!` + + +sub infix:<times>(Int $n, Block $r) { # infix in the middle + for ^$n { + $r(); # You need the explicit parentheses to call the function in `$r`, + # else you'd be referring at the variable itself, kind of like with `&r`. + } +} +3 times -> { say "hello" }; #=> hello + #=> hello + #=> hello + # You're very recommended to put spaces + # around your infix operator calls. + +# For circumfix and post-circumfix ones +sub circumfix:<[ ]>(Int $n) { + $n ** $n +} +say [5]; #=> 3125 + # circumfix is around. Again, not whitespace. + +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). +# Meta-operators, as their name suggests, are *composed* operators. +# Basically, they're operators that apply another operator. + +## * Reduce meta-operator +# It's a prefix meta-operator that takes a binary functions and one or many lists. +# If it doesn't get passed any argument, it either return a "default value" for this operator +# (a value that'd be non-meaningful if contained in a list) or `Any` if there's none. +# Otherwise, it pops an element from the list(s) one at a time, and applies the binary function +# to the last result (or the list's first element) and the popped element. +# To sum a list, you could use the reduce meta-operator with `+`, i.e.: +say [+] 1, 2, 3; #=> 6 +# equivalent to `(1+2)+3` +say [*] 1..5; #=> 120 +# equivalent to `((((1*2)*3)*4)*5)`. + +# You can reduce with any operator, not just with mathematical ones. +# For example, you could reduce with `//` to get the first defined element of a list: +say [//] Nil, Any, False, 1, 5; #=> False + # (Falsey, but still defined) + + +# Default value examples: +say [*] (); #=> 1 +say [+] (); #=> 0 + # In both cases, they're results that, if they were contained in the lists, + # wouldn't have any impact on the final value (since N*1=N and N+0=N). +say [//]; #=> (Any) + # There's no "default value" for `//` + +# You can also call it with a function you made up, using double brackets: +sub add($a, $b) { $a + $b } +say [[&add]] 1, 2, 3; #=> 6 + +## * Zip meta-operator +# This one is an infix meta-operator than also can be used as a "normal" operator. +# It takes an optional binary function (by default, it just creates a pair), +# and will pop one value off of each array and call its binary function on these +# until it runs out of elements. It runs the an array with all these new elements. +(1, 2) Z (3, 4); # ((1, 3), (2, 4)), since by default, the function makes an array +1..3 Z+ 4..6; # (5, 7, 9), using the custom infix:<+> function + +# Since `Z` is list-associative (see the list above), +# you can use it on more than one list +(True, False) Z|| (False, False) Z|| (False, False); # (True, False) + +# And, as it turns out, you can also use the reduce meta-operator with it: +[Z||] (True, False), (False, False), (False, False); # (True, False) + + +## And to end 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` (awk-style) and `fff` (sed-style) 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) { # Note: the parenthesis are superfluous here -- sometimes called "superstitious" + .say if $_ > 50 ff *; # Once the flip-flop reaches 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/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown new file mode 100644 index 00000000..cac4a13e --- /dev/null +++ b/pt-br/markdown-pt.html.markdown @@ -0,0 +1,251 @@ +--- +language: markdown +contributors: + - ["Dan Turkel", "http://danturkel.com/"] +translators: + - ["Miguel Araújo", "https://github.com/miguelarauj1o"] +lang: pt-br +filename: learnmarkdown-pt.md +--- + +Markdown foi criado por John Gruber in 2004. Originado para ser fácil de ler e +escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos também). + +Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e +puxar o projeto (pull request) + +``` +<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é +um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML +em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador +de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você +não pode usar sintaxe remarcação dentro desse conteúdo do elemento.--> + +<!--Markdown também varia de implementação de um analisador para uma próxima. +Este guia vai tentar esclarecer quando as características são universais, ou quando eles são +específico para um determinado parser --> + +<!-- Cabeçalhos --> +<!-- Você pode criar elementos HTML <h1> até <h6> facilmente antecedendo o texto +que deseja estar nesse elemento por um número de hashes (#) --> +# Isto é um cabeçalho <h1> +## Isto é um cabeçalho <h2> +### Isto é um cabeçalho <h3> +#### Isto é um cabeçalho <h4> +##### Isto é um cabeçalho <h5> +###### Isto é um cabeçalho <h6> + +<!-- Markdown também nos fornece duas maneiras alternativas de indicar h1 e h2 --> +Isto é um cabeçalho h1 +====================== + +Isto é um cabeçalho h2 +---------------------- + +<!-- Estilos de texto simples --> +<!-- O texto pode ser facilmente denominado como remarcação itálico, negrito ou tachado usando --> + +*Este texto está em itálico* +_E este também está._ + +**Este texto está em negrito** +__E este também está._ + +***Este texto está em negrito e itálico.*** +**_E este também está_** +*--Danouse! Este também__* + +<!-- Em GitHub Flavored Markdown, que é usado para processar arquivos Markdown +Github, nós também temos: --> + +~~Este texto é processado com tachado.~~ + +<!-- Os parágrafos estão uma ou várias linhas adjacentes de texto separadas por +uma ou múltiplas linhas em branco. --> + +Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal? + +Agora, eu estou no parágrado 2. +... Ainda continuo no parágrafo 2! :) + +Eu estou no parágrafo três. + +<!-- Se você quiser inserir uma tag HTML <br />, você pode acabar com um parágrafo +com dois ou mais espaços e, em seguida, começar um novo parágrafo --> + +Termino com dois espaços (destacar-me para vê-los). + +Há um <br /> acima de mim! + +<!-- Bloco de citações são fáceis e feito com o caractere >. --> + +> Este é um bloco de citação. Você pode +> Enrolar manualmente suas linhas e colocar um `>` antes de cada linha ou você pode +> deixar suas linhas ficarem muito longas e enrolar por conta própria. Não faz diferença, +> desde que eles começam com um `>`. + +> Você também pode usar mais de um nível +>> De recuo? +> Como pura é isso? + +<!-- Listas --> +<!-- As listas não ordenadas podem ser feitas usando asteriscos, positivos ou hífens --> + +* Item +* Item +* Outro item + +ou + ++ Item ++ Item ++ Outro item + +ou + +- Item +- Item +- Um último item + +<!-- Listas ordenadas são feitas com um número seguido por um ponto --> + +1. Item um +2. Item dois +3. Tem três + +<!-- Você não tem poder para rotular os itens corretamente e a remarcação será ainda +tornar os números em ordem, mas isso pode não ser uma boa idéia --> + +1. Item um +1. Item dois +1. Item três +<!-- (Isto é processado da mesma forma que o exemplo acima) --> + +<!-- Você também pode usar subtítulos --> + +1. Item um +2. Item dois +3. Item três + * Sub-item + * Sub-item +4. Item quatro + +<!-- blocos de código --> +<!-- Você pode indicar um bloco de código (que utiliza o elemento <code>) pelo recuo +uma linha com quatro espaços ou uma guia --> + + Isto é código + É assim, sacou? + +<!-- Você pode também re-guia (ou adicionar mais quatro espaços adicionais) para o recuo +dentro do seu código --> + + my_array.each do |item| + puts item + end + +<!-- Código embutido pode ser criada usando o caractere de crase ` --> + +John não sabia nem o que o função 'goto()' fazia! + +<!-- Em Github Flavored Markdown, você pode usar uma sintaxe especial para o código --> + +\`\`\`ruby <!-- exceto remover essas barras invertidas quando você faz isso, apenas ``` +ruby! --> +def foobar + puts "Hello world!" +end +\`\`\` <!-- Aqui também, não barras invertidas, apenas ``` --> + +<-- O texto acima não requer recuo, mas o Github vai usar a sintaxe +destacando do idioma que você especificar após a ``` --> + +<!-- Regra Horizontal (<hr />) --> +<!-- Regras horizontais são facilmente adicionados com três ou mais asteriscos ou hífens, +com ou sem espaços. --> + +*** +--- +- - - +**************** + +<!-- Links --> +<!-- Uma das melhores coisas sobre a remarcação é o quão fácil é fazer ligações. Colocar +o texto a ser exibido entre parênteses rígidos [] seguido pela url em parênteses () --> + +[Click aqui!](http://test.com/) + +<!-- Você também pode adicionar um título link usando aspas dentro dos parênteses --> + +[Click aqui!](http://test.com/ "Link para Test.com") + +<!-- Caminhos relativos funcionam também. --> + +[Ir para música](/música/). + +<!-- Markdown também suporta ligações de estilo de referência --> + +[Clique neste link] [link1] para mais informações sobre isso! +[Além disso, verifique este link] [foobar] se você quiser. + +[link1]: http://test.com/ "Legal!" +[foobar]: http://foobar.biz/ "OK!" + +<!-- O título também pode estar entre aspas simples ou entre parênteses, ou omitido +inteiramente. As referências podem estar em qualquer lugar no documento e os IDs de referência +pode ser qualquer um, desde que eles são únicos. --> + +<!-- Existe também o "nomear implícita", que permite que você use o texto do link como o id --> + +[Este] [] é um link. + +[este]: http://thisisalink.com/ + +<!-- Mas não são usados normalmente--> + +<!-- Imagens --> +<!-- As imagens são feitas da mesma forma que as ligações, mas com um ponto de exclamação na frente! --> + + + +<!-- E estilo de referência funciona como esperado --> + +![Este é o pairar-texto.][Myimage] + +[myimage]: relative/urls/legal/image.jpg "se você precisa de um título, é aqui" + +<!-- Miscelânea --> +<!-- Auto-links --> + +<http://testwebsite.com/> é equivalente a +[http://testwebsite.com/](http://testwebsite.com/) + +<!-- Auto-links para e-mails --> + +<foo@bar.com> + +<!-- Escapando caracteres --> + +Quero digitar * Este texto entre asteriscos *, mas eu não quero que ele seja +em itálico, então eu faço o seguinte: \*Este texto entre asteriscos \*. + +<!-- Tabelas --> +<!-- Tabelas estão disponíveis apenas no Github Flavored Markdown e são ligeiramente +complicadas, mas se você realmente quer: --> + +| Col1 | Col2 | Col3 | +| :----------- | :------: | ------------: | +| esquerda-alin| Centrado | direita-alinh | +| blah | blah | blah | + +<!-- Ou, para os mesmos resultados --> + +Col 1 | Col2 | Col3 +:-- | :-: | --: +Ugh isso é tão feio | faça isto | parar + +<!-- O fim! --> + +``` +Para mais informações, confira o post oficial de John Gruber de sintaxe [aqui](http://daringfireball.net/projects/markdown/syntax) +e de Adam Pritchard grande cheatsheet [aqui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). diff --git a/zh-cn/julia-cn.html.markdown b/zh-cn/julia-cn.html.markdown new file mode 100644 index 00000000..7afc9043 --- /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", "http://oyanglul.us"] +lang: zh-cn +--- + +```ruby +# 单行注释只需要一个井号 +#= 多行注释 + 只需要以 '#=' 开始 '=#' 结束 + 还可以嵌套. +=# + +#################################################### +## 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 + # +``` |