Merge branch 'master' of github.com:scala/scala.github.com

Author: xeno-by

ja/overviews/collections/seqs.md.disabled renamed to ja/overviews/collections/seqs.md

@@ -10,7 +10,7 @@ outof: 13
 ---
 **Denys Shabalin** <span class="label warning" style="float: right;">EXPERIMENTAL</span>
 
-## Modifiers {:#modifiers}
+## Modifiers
 
 Every definition except packages and package objects have associtated modifiers object which contains following data:
 
@@ -62,7 +62,7 @@ Considering the fact that definitions might contain various low-level flags adde
 
     scala> val q"$_ def f" = q"@foo @bar implicit def f"
 
-## Templates {:#templates}
+## Templates
 
 Templates are a common abstraction in definition trees that is used in new expressions, classes, traits, objects, package objects. Although there is no interpolator for it at the moment we can illustrate its structure on the example of new expression (similar handling will applly to all other template-bearing trees):
 
@@ -111,9 +111,9 @@ So template consists of:
         scala> val q"new { ..$body }" = q"new { val x = 1; def y = 'y }"
         body: List[universe.Tree] = List(val x = 1, def y = scala.Symbol("y"))
 
-## Val and Var Definitions {:#val-var}
+## Val and Var Definitions
 
-Vals and vars allow you to define immutable and mutable variables correspondingly. Additionally they are also used to represent [function](/overviews/quasiquotes/expression-details.html#function), [class](#class) and [method](#method) paremeters.
+Vals and vars allow you to define immutable and mutable variables correspondingly. Additionally they are also used to represent [function](/overviews/quasiquotes/expression-details.html#function), [class](#class-definition) and [method](#method-definition) paremeters.
 
 Each val and var consistents of four components: modifiers, name, type tree and a right hand side:
 
@@ -126,7 +126,7 @@ Each val and var consistents of four components: modifiers, name, type tree and
     tpt: universe.Tree = <type ?>
     rhs: universe.Tree = 2
 
-If type of the val isn't explicitly specified by the user an [empty type](/overviews/quasiquotes/type-details.html#empty) is used as tpt.
+If type of the val isn't explicitly specified by the user an [empty type](/overviews/quasiquotes/type-details.html#empty-type) is used as tpt.
 
 Vals and vars are disjoint (they don't match one another):
 
@@ -142,7 +142,7 @@ Vars always have `MUTABLE` flag in their modifiers:
     tpt: universe.Tree = <type ?>
     rhs: universe.Tree = 2
 
-## Pattern Definitions {:#pattern}
+## Pattern Definitions
 
 Pattern definitions allow to use scala pattern matching capabilities to define variables. Unlike
 val and var definitions, pattern definitions are not first-class and they are get represented
@@ -202,7 +202,7 @@ Simiarly one can also construct a mutable pattern definition:
 
     q"$mods var $pat: $tpt = $rhs"
 
-## Type Definition {:#type}
+## Type Definition
 
 Type definition have two possible shapes: abstract type definitions and alias type definitions.
 
@@ -237,7 +237,7 @@ Due to low level uniform representation of type aliases and abstract types one m
 
 Where `tpt` has a `TypeBoundsTree(low, high)` shape.
 
-## Method Definition {:#method}
+## Method Definition
 
 Each method consists of modifiers, name, type arguments, value arguments, return type and a body:
 
@@ -249,7 +249,7 @@ Each method consists of modifiers, name, type arguments, value arguments, return
     tpt: universe.Tree = <type ?>
     body: universe.Tree = 1
 
-Type arguments are [type definitions](#type) and value arguments are [val definitions](#val-var). Inferred return type is represented as [empty type](/overviews/quasiquotes/type-details.html#empty). If body of the method is [empty expression](/overviews/quasiquotes/expression-details.html#empty) it means that method is abstract.
+Type arguments are [type definitions](#type-definition) and value arguments are [val definitions](#val-and-var-definitions). Inferred return type is represented as [empty type](/overviews/quasiquotes/type-details.html#empty-type). If body of the method is [empty expression](/overviews/quasiquotes/expression-details.html#empty) it means that method is abstract.
 
 Alternatively you can also deconstruct arguments separating implicit and non-implicit parameters:
 
@@ -267,7 +267,7 @@ This way of parameter handling will still work if method doesn\'t have any impli
     implparams: List[universe.ValDef] = List()
     body: universe.Tree = x.$plus(y)
 
-## Secondary Constructor Definition {:#ctor}
+## Secondary Constructor Definition
 
 Secondary constructors are special kinds of methods that have following shape:
 
@@ -288,19 +288,19 @@ Due to low level underlying representation of trees secondary constructors are r
     tpt: universe.Tree = <type ?>
     body: universe.Tree = <init>(0)
 
-## Class Definition {:#class}
+## Class Definition
 
 Classes have a following structure:
 
     q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self => ..$stats }"
 
 As you probably already see the right part after extends is just a [template](#templates). Apart from it and modifiers classes
 also have primary constructor which consists of constructor modifiers, type and value parameters which behave very much like
-[method](#method) modifiers and parameters.
+[method](#method-definition) modifiers and parameters.
 
-## Trait Definition {:#trait}
+## Trait Definition
 
-Syntactically traits are quite similar to [classes](#class) sans value parameters and constructor modifiers:
+Syntactically traits are quite similar to [classes](#class-definition) sans value parameters and constructor modifiers:
 
      q"$mods trait $tpname[..$tparams] extends { ..$earlydefns } with ..$parents { $self => ..$stats }"
 
@@ -316,13 +316,13 @@ A workaround it to always extract modifiers with wildcard pattern:
     name: universe.TypeName = X
     stats: List[universe.Tree] = List(def x: Int)
 
-## Object Definition {:#object}
+## Object Definition
 
-Syntactically objects are quite similar [classes](#class) without constructors:
+Syntactically objects are quite similar [classes](#class-definition) without constructors:
 
     q"$mods object $tname extends { ..$earlydefns } with ..$parents { $self => ..$stats }"
 
-## Package Definition {:#package}
+## Package Definition
 
 Packages are a fundamental primitive to organize source code. You can express them in quasiquotes as:
 
@@ -350,7 +350,7 @@ Packages are a fundamental primitive to organize source code. You can express th
 Quasiquotes don\'t support inline package definition syntax that are usually used in the
 header of the source file (but it's equivalent to the supported one in terms of ASTs).
 
-## Package Object Definition{:#package-object}
+## Package Object Definition
 
 Package objects are a cross between packages and object:
 

ja/overviews/collections/sets.md.disabled renamed to ja/overviews/collections/sets.md

@@ -10,7 +10,7 @@ outof: 13
 ---
 **Denys Shabalin** <span class="label warning" style="float: right;">EXPERIMENTAL</span>
 
-## Empty {:#empty}
+## Empty
 
 `q""` is used to indicate that some part of the tree is not provided by the user:
 
@@ -21,7 +21,7 @@ outof: 13
 
 Default toString formats `q""` as `<empty>`.
 
-## Literal {:#literal}
+## Literal
 
 Scala has a number of default built-in literals:
 
@@ -45,7 +45,7 @@ Thanks to [lifting](/overviews/quasiquotes/lifting.html) you can also easily cre
     scala> val one = q"$x"
     one: universe.Tree = 1
 
-This would work the same way for all literal types (see [standard liftables](/overviews/quasiquotes/lifting.html#standard) except `Null`. Lifting of `null` value and `Null` type isn't supported, use `q"null"` if you really mean to create null literal:
+This would work the same way for all literal types (see [standard liftables](/overviews/quasiquotes/lifting.html#standard-liftables) except `Null`. Lifting of `null` value and `Null` type isn't supported, use `q"null"` if you really mean to create null literal:
 
     scala> val x = null
     scala> q"$x"
@@ -58,9 +58,9 @@ During deconstruction you can use [unlifting](/overviews/quasiquotes/unlifting.h
     scala> val q"${x: Int}" = q"1"
     x: Int = 1
 
-Similarly it would work with all the literal types except `Null`. (see [standard unliftables](/overviews/quasiquotes/unlifting.html#standard))
+Similarly it would work with all the literal types except `Null`. (see [standard unliftables](/overviews/quasiquotes/unlifting.html#standard-unliftables))
 
-## Identifier and Selection {:#ref}
+## Identifier and Selection
 
 Identifiers and member selections are two fundamental primitives that let you refer to other definitions. Combination of two of them is also known `RefTree`.
 
@@ -98,7 +98,7 @@ Similarly you can create and extract member selections:
     scala> val q"foo.$name" = selected
     name: universe.TermName = bar
 
-## Super and This {:#super-this}
+## Super and This
 
 One can use this and super to select precise members within inheritance chain.
 
@@ -129,7 +129,7 @@ Similarly for super we have:
     qual: universe.TypeName = T
     field: universe.Name = foo
 
-## Application and Type Application {:#application}
+## Application and Type Application
 
 Value applications and type applications are two fundamental parts out of which one can construct calls to Scala functions and methods. Lets assume that we would like to handle function calls to the following method:
 
@@ -187,7 +187,7 @@ Similarly to type arguments, implicit value arguments are automatically inferred
     stats: List[universe.Tree] = List(def g(x: Int)(implicit y: Int): Int = x.+(y), implicit val y: Int = 3)
     argss: List[List[universe.Tree]] = List(List(2), List(y))
 
-## Assign and Update {:#assign-update}
+## Assign and Update
 
 Assign and update are two related ways to explictly mutate a variable or collection:
 
@@ -222,7 +222,7 @@ On the other hand if you want to treat this two cases separately it's also possi
     update array at List(0) with 1
 
 
-## Return {:#return}
+## Return
 
 Return expressions is used to perform early return from a function.
 
@@ -232,7 +232,7 @@ Return expressions is used to perform early return from a function.
     scala> val q"return $expr" = ret
     expr: universe.Tree = 2.$plus(2)
 
-## Throw {:#throw}
+## Throw
 
 Throw expression is used to throw a throwable:
 
@@ -242,7 +242,7 @@ Throw expression is used to throw a throwable:
     scala> val q"throw $expr" = thr
     expr: universe.Tree = new Exception()
 
-## Ascription {:#ascription}
+## Ascription
 
 Ascriptions lets users to annotate type of intermidiate expression:
 
@@ -253,7 +253,7 @@ Ascriptions lets users to annotate type of intermidiate expression:
     expr: universe.Tree = 1.$plus(1)
     tpt: universe.Tree = Int
 
-## Annotation {:#annotated}
+## Annotation
 
 Expressions can be annotated:
 
@@ -270,9 +270,9 @@ It's important to mention that such pattern won't match if we combine annotation
     scala.MatchError: (1.$plus(1): Int @positive) (of class scala.reflect.internal.Trees$Typed)
       ... 32 elided
 
-In this case we need to deconstruct it as [ascription](#ascription) and then deconstruct `tpt` as [annotated type](/overviews/quasiquotes/type-details.html#annotated).
+In this case we need to deconstruct it as [ascription](#ascription) and then deconstruct `tpt` as [annotated type](/overviews/quasiquotes/type-details.html#annotated-type).
 
-## Tuple {:#tuple}
+## Tuple
 
 Tuples are heteregeneous data structures with built-in user-friendly syntax. The syntax itself is just a sugar that maps onto `scala.TupleN` calls:
 
@@ -313,7 +313,7 @@ And unit as nullary tuple:
     scala> val q"(..$elems)" = q"()"
     elems: List[universe.Tree] = List()
 
-## Block {:#block}
+## Block
 
 Blocks are a fundamental primitive to express sequence of actions or bindings. `q"..."` interpolator is an equivalent of a block. It allows to express more than one expression seperated by semicolon or a newline:
 
@@ -383,9 +383,9 @@ Zero-element block is equivalent to synthetic unit (one that was inserted by the
     scala> val syntheticUnit = q"..$stats"
     syntheticUnit: universe.Tree = ()
 
-Such units are used in empty else branches of [ifs](#if) and empty bodies of [case clauses](#match) making it convenient to work with those cases as with zero-element blocks.
+Such units are used in empty else branches of [ifs](#if) and empty bodies of [case clauses](#pattern-match) making it convenient to work with those cases as with zero-element blocks.
 
-## If {:#if}
+## If
 
 There are two varieties of if expressions: those with else clause and without it:
 
@@ -401,7 +401,7 @@ There are two varieties of if expressions: those with else clause and without it
 
 No-else clause is equivalent to else clause that contains a synthetic unit literal ([empty block](#block)).
 
-## Pattern Match {:#match}
+## Pattern Match
 
 Pattern matching is cornerstone feature of Scala that lets you deconstruct values into their components:
 
@@ -433,7 +433,7 @@ Case clause without body is equivalent to one holding synthetic unit literal ([e
 
 No-guard is represented with the help of [empty expression](#empty).
 
-## Try {:#try}
+## Try
 
 Try expression is used to handle possible error conditions and ensure consistent state via finally. Both error handling cases and finally clause are optional.
 
@@ -454,9 +454,9 @@ Try expression is used to handle possible error conditions and ensure consistent
     b: List[universe.CaseDef] = List()
     c: universe.Tree = f
 
-Similarly to [pattern matching](#match) cases can be further deconstructed with `cq"..."`. No-finally clause is represented with the help of [empty expression](#empty).
+Similarly to [pattern matching](#pattern-match) cases can be further deconstructed with `cq"..."`. No-finally clause is represented with the help of [empty expression](#empty).
 
-## Function {:#function}
+## Function
 
 There are three ways to create anonymous function:
 
@@ -474,8 +474,8 @@ on type inference to infer its type. Last one explicitly defines function parame
 to implementation restriction second notation can only be used in parenthesis or inside other
 expression. If you leave them out you have to specify parameter types.
 
-Parameters are represented as [Vals](/overviews/quasiquotes/definition-details.html#val-var). If you want to programmatically create val that should have
-its type inferred you need to use [empty type](/overviews/quasiquotes/type-details.html#empty):
+Parameters are represented as [Vals](/overviews/quasiquotes/definition-details.html#val-and-var-definitions). If you want to programmatically create val that should have
+its type inferred you need to use [empty type](/overviews/quasiquotes/type-details.html#empty-type):
 
     scala> val tpt = tq""
     tpt: universe.TypeTree = <type ?>
@@ -508,7 +508,7 @@ You can also tear arguments further apart:
 It's recommended to use underscore pattern in place of [modifiers](/overviews/quasiquotes/definition-details.html#modifiers) even if you don't plan to work
 with them as parameters may contains additional flags which might cause match errors.
 
-## Partial Function {:#partial-function}
+## Partial Function
 
 Partial functions are a neat syntax that lets you express functions with
 limited domain with the help of pattern matching:
@@ -528,7 +528,7 @@ trees for match expressions. Despite this fact they do not match one another:
   scala> val q"$expr match { case ..$cases }" = pf
   scala.MatchError: ...
 
-## While and Do-While Loops {:#while}
+## While and Do-While Loops
 
 While and do-while loops are low-level control structures that used when performance of iteration
 is critical:
@@ -563,7 +563,7 @@ is critical:
     body: universe.Tree = x.$minus$eq(1)
     cond: universe.Tree = x.$greater(0)
 
-## For and For-Yield Loops {:#for}
+## For and For-Yield Loops
 
 For and For-Yield expressions allow to write monadic style comprehensions that desugar into calls to `map`, `flatMap`, `foreach` and `withFilter` methods:
 
@@ -595,7 +595,7 @@ It's important to mention that For and For-Yield do not cross-match each other:
     scala> val q"for (..$enums) $body" = `for-yield`
     scala.MatchError: ...
 
-## New {:#new}
+## New
 
 New expression lets you construct an instance of given type possibly refining it with other types or definitions:
 
@@ -605,7 +605,7 @@ New expression lets you construct an instance of given type possibly refining it
 
 See [templates](/overviews/quasiquotes/definition-details.html#templates) section for details.
 
-## Import {:#import}
+## Import
 
 Import trees consist of reference and a list of selectors:
 

overviews/quasiquotes/definition-details.md

@@ -10,7 +10,7 @@ outof: 13
 ---
 **Denys Shabalin** <span class="label warning" style="float: right;">EXPERIMENTAL</span>
 
-In [Project Palladium](www.scalareflect.org) we are working on the following features that target future versions of Scala:
+In the [scala.meta](http://scalameta.org) project we are working on the following features that target future versions of Scala:
 
 * Hygiene: [SI-7823](https://issues.scala-lang.org/browse/SI-7823)
 * Alternative to Scheme's ellipsis: [SI-8164](https://issues.scala-lang.org/browse/SI-8164)

overviews/quasiquotes/expression-details.md

@@ -16,7 +16,7 @@ Sophisticated macro systems such as Racket's have mechanisms that make macros hy
 
 Preventing name clashes between regular and generated code means two things. First, we must ensure that regardless of the context in which we put generated code, its meaning isn't going to change (*referential transparency*). Second, we must make certain that regardless of the context in which we splice regular code, its meaning isn't going to change (often called *hygiene in the narrow sense*). Let's see what can be done to this end on a series of examples.
 
-## Referential transparency {:#referential-transparency}
+## Referential transparency
 
 What referential transparency means is that quasiquotes should remember the lexical context in which they are defined. For instance, if there are imports provided at the definition site of the quasiquote, then these imports should be used to resolve names in the quasiquote. Unfortunately, this is not the case at the moment, and here's an example:
 
@@ -86,7 +86,7 @@ And wrapper will be resolved to `example.Test.wrapper` rather than intended `exa
          q"$wrapper($x)"
        }
 
-## Hygiene in the narrow sense {:#hygiene-in-the-narrow-sense}
+## Hygiene in the narrow sense
 
 What hygiene in the narrow sense means is that quasiquotes shouldn't mess with the bindings of trees that are unquoted into them. For example, if a macro argument unquoted into a macro expansion was originally referring to some variable in enclosing lexical context, then this reference should remain in force after macro expansion, regardless of what code was generated for the macro expansion. Unfortunately, we don't have automatic facilities to ensure this, and that can lead to unexpected situations: