Fixed tutor links

Author: DavyLandman

doc/TypePal/Collector/Collector.md

@@ -112,7 +112,7 @@ Scope management amounts to entering a new scope, leave the current scope and re
 ```
 In order to check consistency, `leaveScope` has the inner scope that it is supposed to be leaving as argument.
 
-Here is a simple example how the `let` expression in [the Fun language]((examples::fun)) handles subscopes:
+Here is a simple example how the `let` expression in [the Fun language]((Examples)) handles subscopes:
 
 ```rascal
 void collect(current: (Expression) `let <Id name> : <Type tp> = <Expression exp1> in <Expression exp2> end`, Collector c) {  
@@ -248,7 +248,7 @@ TypePal is based on nested scopes and path between scopes. The former represent
 
 `addPathToDef` is typically used to create an _import_ or _extend_ path between program parts. `occ` is an occurence of a name that should be defined elsewhere in one of the given roles. The effect is to add a `pathRole` path between the current scope and the definition.
 
-Here is an example taken from [the language ModFun]((examples::modfun)):
+Here is an example taken from [the language ModFun]((Examples)):
 ```rascal
 void collect(current: (ImportDecl) `import <ModId mid> ;`, Collector c){
      c.addPathToDef(mid, {moduleId()}, importPath());
@@ -266,7 +266,7 @@ Similar to `addPathToDef` for the occurrence of a qualified names rather than a
 ```
 `occ` is a parse tree with has a certain type. The effect is to add a `pathRole` path between the current scope and the definition of that type.
 
-A prime example is type checking of [Pascal]((examples::pascal))'s `with` statement which _opens_ the definition of a record type and makes all defined fields available in the body of the `with` statement. Here we create a `withPath` between the scope of the with statement and all definitions of the record types of the given record variables:
+A prime example is type checking of [Pascal]((Examples))'s `with` statement which _opens_ the definition of a record type and makes all defined fields available in the body of the `with` statement. Here we create a `withPath` between the scope of the with statement and all definitions of the record types of the given record variables:
 
 ```rascal
 void collect(current: (WithStatement) `with <{RecordVariable ","}+ recordVars> do <Statement withStat>`, Collector c){
@@ -323,7 +323,7 @@ There are three functions to describe the occurrence of a name in a parse tree a
 ```
 The parse tree `occ` is a use to be resolved in the current scope in one of the given roles `idRoles`. The use of a variable in an expression is typically modelled with this use function.
 
-Here is an example from [the Calc language]((examples::calc)):
+Here is an example from [the Calc language]((Examples)):
 ```rascal
 void collect(current: (Exp) `<Id name>`, Collector c){
     c.use(name, {variableId()});
@@ -352,7 +352,7 @@ where
 * `selector`: is the name to be selected from that named type.
 * `idRolesSel`:  are the IdRoles allowed for the selector.
 
-Here is an example of field selection from a record in [the Struct language]((examples::struct)):
+Here is an example of field selection from a record in [the Struct language]((Examples)):
 
 ```rascal
 void collect(current:(Expression)`<Expression lhs> . <Id fieldName>`, Collector c) {
@@ -383,7 +383,7 @@ ATypes may contain type variables and new type variables can be created using `n
 
 Type variables can be bound via unification.
 
-Here is an example of a call expression taken from [the UntypedFun language]((examples::untypedFun)):
+Here is an example of a call expression taken from [the UntypedFun language]((Examples)):
 
 ```rascal
 void collect(current: (Expression) `<Expression exp1>(<Expression exp2>)`, Collector c) { 
@@ -415,7 +415,7 @@ The function `fact` registers known type information for a program fragment `src
 ```
 where `atype` can be either an `AType` or a `Tree`. In the latter case the type of that Tree is used when available.
 
-Here are two examples from [the Calc language]((examples::calc)):
+Here are two examples from [the Calc language]((Examples)):
 ```rascal
 void collect(current: (Exp) `<Integer integer>`, Collector c){
     c.fact(current, intType()); //<1>

doc/TypePal/Configuration/Configuration.md

@@ -104,7 +104,7 @@ Accept myIsAcceptablePath(TModel tm, loc def, Use use, PathRole pathRole) {
 `mayOverload` determines whether a set of definitions (`defs`) are allowed to be overloaded,
 given their definitions (`defines`).
 
-For example, [Featherweight Java]((examples::fwjava::Checker)) the only allowed overloading is between class names and constructor names.
+For example, [Featherweight Java]((Examples)) the only allowed overloading is between class names and constructor names.
 ```rascal
 bool fwjMayOverload (set[loc] defs, map[loc, Define] defines) {
     roles = {defines[def].idRole | def <- defs};  //<1>
@@ -158,7 +158,7 @@ The function `instantiateTypeParameters` defines instantiation of *language-spec
 `instantiateTypeParameters` will match `def` with `ins` and the resulting bindings will be used to instantiate `act`.
 The instantiated version of `act` is returned.
 
-In the [StructParameters demo]((examples::structParameters::Checker)) parameterized structs (records) are defined. 
+In the [StructParameters demo]((Examples)) parameterized structs (records) are defined. 
 The formal type of such a struct is ``structDef(str name, list[str] formals)``, 
 i.e., a struct has a name and a list of named formal type parameters.
 The actual type of a struct is ``structType(str name, list[AType] actuals)``, 
@@ -191,7 +191,7 @@ of indirect type computations such as `useViaType` and `getTypeInType`. When `at
   In more sophisticated cases the list may contain a list of named types to be considered.
 * A list of roles in which the type name can be bound.
 
-Here are the definitions for the [Struct demo]((examples::struct::Checker)):
+Here are the definitions for the [Struct demo]((Examples)):
 ```rascal
 tuple[list[str] typeNames, set[IdRole] idRoles] structGetTypeNamesAndRole(structType(str name)){
     return <[name], {structId()}>; //<1>
@@ -226,7 +226,7 @@ In the Rascal type checker common keyword parameters of data declarations are ha
 `getTypeInNamelessType` describes field selection on built-types that have not been explicitly declared with a name.
 A case in point is a `length` field on a built-in string type.
 
-In [the StaticFields demo]((examples::staticFields::Checker)))) this is done as follows:
+In [the StaticFields demo]((Examples)))) this is done as follows:
 ```rascal
 AType staticFieldsGetTypeInNamelessType(AType containerType, Tree selector, loc scope, Solver s){
     if(containerType ### strType() && "<selector>" ### "length") return intType();

doc/TypePal/Examples/Examples.md

@@ -55,7 +55,7 @@ To get you started more quickly, we give below a list of complete TypePal-based
 ##### ModFun
 
 
-| *What*        | Extension of [Fun]((examples::fun)) with modules |
+| *What*        | Extension of [Fun](#fun) with modules |
 | --- | --- |
 | *Illustrates* | PathRole, addPathToDef |
 | *Source*      | https://github.com/cwi-swat/typepal/tree/master/src/examples/modfun |

doc/TypePal/Solver/Solver.md

@@ -155,7 +155,7 @@ The workhorse of TypePal is the function `getType` that determines  the type of
 ```
 `src` may either be a `Tree` (i.e., a parse tree fragment) or a `loc` (the source location of a parse tree fragment).
 
-Here is how `getType` is used in [the Pico example]((examples::pico)) to check the addition operator:
+Here is how `getType` is used in [the Pico example]((Examples)) to check the addition operator:
 
 * two integer arguments give an integer result;
 * two string arguments give a string result;