Created
February 17, 2017 20:20
-
-
Save janekdb/2c56beffb64ca85e373aac31c66cc922 to your computer and use it in GitHub Desktop.
diff on Scala spec between Jekyll 2.5.3 and 3.3.0 (https://github.com/scala/scala/pull/5713)
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| --- build/spec/07-implicits.html 2017-02-17 19:59:29.867811207 +0000 | |
| +++ build-spec-2.5.3/07-implicits.html 2017-02-17 19:58:10.555811809 +0000 | |
| @@ -113,20 +113,20 @@ | |
| <p>The following code defines an abstract class of monoids and | |
| two concrete implementations, <code>StringMonoid</code> and | |
| <code>IntMonoid</code>. The two implementations are marked implicit.</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">abstract</span> <span class="k">class</span> <span class="nc">Monoid</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="nc">extends</span> <span class="nc">SemiGroup</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="o">{</span> | |
| - <span class="k">def</span> <span class="n">unit</span><span class="k">:</span> <span class="kt">A</span> | |
| - <span class="k">def</span> <span class="n">add</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">A</span><span class="o">,</span> <span class="n">y</span><span class="k">:</span> <span class="kt">A</span><span class="o">)</span><span class="k">:</span> <span class="kt">A</span> | |
| -<span class="o">}</span> | |
| -<span class="k">object</span> <span class="nc">Monoids</span> <span class="o">{</span> | |
| - <span class="k">implicit</span> <span class="k">object</span> <span class="nc">stringMonoid</span> <span class="k">extends</span> <span class="nc">Monoid</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span> <span class="o">{</span> | |
| - <span class="k">def</span> <span class="n">add</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">String</span><span class="o">,</span> <span class="n">y</span><span class="k">:</span> <span class="kt">String</span><span class="o">)</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">concat</span><span class="o">(</span><span class="n">y</span><span class="o">)</span> | |
| - <span class="k">def</span> <span class="n">unit</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=</span> <span class="s">""</span> | |
| - <span class="o">}</span> | |
| - <span class="k">implicit</span> <span class="k">object</span> <span class="nc">intMonoid</span> <span class="k">extends</span> <span class="nc">Monoid</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span> <span class="o">{</span> | |
| - <span class="k">def</span> <span class="n">add</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span> <span class="n">y</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span> | |
| - <span class="k">def</span> <span class="n">unit</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=</span> <span class="mi">0</span> | |
| - <span class="o">}</span> | |
| -<span class="o">}</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">abstract class Monoid[A] extends SemiGroup[A] { | |
| + def unit: A | |
| + def add(x: A, y: A): A | |
| +} | |
| +object Monoids { | |
| + implicit object stringMonoid extends Monoid[String] { | |
| + def add(x: String, y: String): String = x.concat(y) | |
| + def unit: String = "" | |
| + } | |
| + implicit object intMonoid extends Monoid[Int] { | |
| + def add(x: Int, y: Int): Int = x + y | |
| + def unit: Int = 0 | |
| + } | |
| +} | |
| </code></pre></div> | |
| <h2 id="implicit-parameters">Implicit Parameters</h2> | |
| @@ -189,9 +189,9 @@ | |
| <p>Assuming the classes from the <a href="#example-monoid"><code>Monoid</code> example</a>, here is a | |
| method which computes the sum of a list of elements using the | |
| monoid's <code>add</code> and <code>unit</code> operations.</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="n">sum</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">xs</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">A</span><span class="o">])(</span><span class="k">implicit</span> <span class="n">m</span><span class="k">:</span> <span class="kt">Monoid</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=</span> | |
| - <span class="k">if</span> <span class="o">(</span><span class="n">xs</span><span class="o">.</span><span class="n">isEmpty</span><span class="o">)</span> <span class="n">m</span><span class="o">.</span><span class="n">unit</span> | |
| - <span class="k">else</span> <span class="n">m</span><span class="o">.</span><span class="n">add</span><span class="o">(</span><span class="n">xs</span><span class="o">.</span><span class="n">head</span><span class="o">,</span> <span class="n">sum</span><span class="o">(</span><span class="n">xs</span><span class="o">.</span><span class="n">tail</span><span class="o">))</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">def sum[A](xs: List[A])(implicit m: Monoid[A]): A = | |
| + if (xs.isEmpty) m.unit | |
| + else m.add(xs.head, sum(xs.tail)) | |
| </code></pre></div> | |
| <p>The monoid in question is marked as an implicit parameter, and can therefore | |
| be inferred based on the type of the list. | |
| @@ -210,37 +210,37 @@ | |
| is the following method from module <code>scala.List</code>, which injects | |
| lists into the <code>scala.Ordered</code> class, provided the element | |
| type of the list is also convertible to this type.</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">implicit</span> <span class="k">def</span> <span class="n">list2ordered</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">x</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span> | |
| - <span class="o">(</span><span class="k">implicit</span> <span class="n">elem2ordered</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=></span> <span class="nc">Ordered</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span><span class="k">:</span> <span class="kt">Ordered</span><span class="o">[</span><span class="kt">List</span><span class="o">[</span><span class="kt">A</span><span class="o">]]</span> <span class="k">=</span> | |
| - <span class="o">...</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">implicit def list2ordered[A](x: List[A]) | |
| + (implicit elem2ordered: A => Ordered[A]): Ordered[List[A]] = | |
| + ... | |
| </code></pre></div> | |
| <p>Assume in addition a method</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">implicit</span> <span class="k">def</span> <span class="n">int2ordered</span><span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span><span class="k">:</span> <span class="kt">Ordered</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">implicit def int2ordered(x: Int): Ordered[Int] | |
| </code></pre></div> | |
| <p>that injects integers into the <code>Ordered</code> class. We can now | |
| define a <code>sort</code> method over ordered lists:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="n">sort</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">xs</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">A</span><span class="o">])(</span><span class="k">implicit</span> <span class="n">a2ordered</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=></span> <span class="nc">Ordered</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span> <span class="k">=</span> <span class="o">...</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">def sort[A](xs: List[A])(implicit a2ordered: A => Ordered[A]) = ... | |
| </code></pre></div> | |
| <p>We can apply <code>sort</code> to a list of lists of integers | |
| <code>yss: List[List[Int]]</code> | |
| as follows:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="n">sort</span><span class="o">(</span><span class="n">yss</span><span class="o">)</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">sort(yss) | |
| </code></pre></div> | |
| <p>The call above will be completed by passing two nested implicit arguments:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="n">sort</span><span class="o">(</span><span class="n">yss</span><span class="o">)(</span><span class="n">xs</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span> <span class="k">=></span> <span class="n">list2ordered</span><span class="o">[</span><span class="kt">Int</span><span class="o">](</span><span class="n">xs</span><span class="o">)(</span><span class="n">int2ordered</span><span class="o">))</span> <span class="o">.</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">sort(yss)(xs: List[Int] => list2ordered[Int](xs)(int2ordered)) . | |
| </code></pre></div> | |
| <p>The possibility of passing implicit arguments to implicit arguments | |
| raises the possibility of an infinite recursion. For instance, one | |
| might try to define the following method, which injects <em>every</em> type into the | |
| <code>Ordered</code> class:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">implicit</span> <span class="k">def</span> <span class="n">magic</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">x</span><span class="k">:</span> <span class="kt">A</span><span class="o">)(</span><span class="k">implicit</span> <span class="n">a2ordered</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=></span> <span class="nc">Ordered</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span><span class="k">:</span> <span class="kt">Ordered</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=</span> | |
| - <span class="n">a2ordered</span><span class="o">(</span><span class="n">x</span><span class="o">)</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">implicit def magic[A](x: A)(implicit a2ordered: A => Ordered[A]): Ordered[A] = | |
| + a2ordered(x) | |
| </code></pre></div> | |
| <p>Now, if one tried to apply | |
| <code>sort</code> to an argument <code>arg</code> of a type that did not have | |
| another injection into the <code>Ordered</code> class, one would obtain an infinite | |
| expansion:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="n">sort</span><span class="o">(</span><span class="n">arg</span><span class="o">)(</span><span class="n">x</span> <span class="k">=></span> <span class="n">magic</span><span class="o">(</span><span class="n">x</span><span class="o">)(</span><span class="n">x</span> <span class="k">=></span> <span class="n">magic</span><span class="o">(</span><span class="n">x</span><span class="o">)(</span><span class="n">x</span> <span class="k">=></span> <span class="o">...</span> <span class="o">)))</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">sort(arg)(x => magic(x)(x => magic(x)(x => ... ))) | |
| </code></pre></div> | |
| <p>To prevent such infinite expansions, the compiler keeps track of | |
| a stack of “open implicit types” for which implicit arguments are currently being | |
| @@ -285,9 +285,9 @@ | |
| <p>When typing <code>sort(xs)</code> for some list <code>xs</code> of type <code>List[List[List[Int]]]</code>, | |
| the sequence of types for | |
| which implicit arguments are searched is</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nc">List</span><span class="o">[</span><span class="kt">List</span><span class="o">[</span><span class="kt">Int</span><span class="o">]]</span> <span class="k">=></span> <span class="nc">Ordered</span><span class="o">[</span><span class="kt">List</span><span class="o">[</span><span class="kt">List</span><span class="o">[</span><span class="kt">Int</span><span class="o">]]],</span> | |
| -<span class="nc">List</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span> <span class="k">=></span> <span class="nc">Ordered</span><span class="o">[</span><span class="kt">List</span><span class="o">[</span><span class="kt">Int</span><span class="o">]]</span> | |
| -<span class="nc">Int</span> <span class="k">=></span> <span class="nc">Ordered</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">List[List[Int]] => Ordered[List[List[Int]]], | |
| +List[Int] => Ordered[List[Int]] | |
| +Int => Ordered[Int] | |
| </code></pre></div> | |
| <p>All types share the common type constructor <code>scala.Function1</code>, | |
| but the complexity of the each new type is lower than the complexity of the previous types. | |
| @@ -297,13 +297,13 @@ | |
| <p>Let <code>ys</code> be a list of some type which cannot be converted | |
| to <code>Ordered</code>. For instance:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">val</span> <span class="n">ys</span> <span class="k">=</span> <span class="nc">List</span><span class="o">(</span><span class="k">new</span> <span class="nc">IllegalArgumentException</span><span class="o">,</span> <span class="k">new</span> <span class="nc">ClassCastException</span><span class="o">,</span> <span class="k">new</span> <span class="nc">Error</span><span class="o">)</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">val ys = List(new IllegalArgumentException, new ClassCastException, new Error) | |
| </code></pre></div> | |
| <p>Assume that the definition of <code>magic</code> above is in scope. Then the sequence | |
| of types for which implicit arguments are searched is</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="nc">Throwable</span> <span class="k">=></span> <span class="nc">Ordered</span><span class="o">[</span><span class="kt">Throwable</span><span class="o">],</span> | |
| -<span class="nc">Throwable</span> <span class="k">=></span> <span class="nc">Ordered</span><span class="o">[</span><span class="kt">Throwable</span><span class="o">],</span> | |
| -<span class="o">...</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">Throwable => Ordered[Throwable], | |
| +Throwable => Ordered[Throwable], | |
| +... | |
| </code></pre></div> | |
| <p>Since the second type in the sequence is equal to the first, the compiler | |
| will issue an error signalling a divergent implicit expansion.</p> | |
| @@ -352,18 +352,18 @@ | |
| <h6 id="example-ordered">Example Ordered</h6> | |
| <p>Class <code>scala.Ordered[A]</code> contains a method</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="k">def</span> <span class="o"><=</span> <span class="o">[</span><span class="kt">B</span> <span class="k">>:</span> <span class="kt">A</span><span class="o">](</span><span class="n">that</span><span class="k">:</span> <span class="kt">B</span><span class="o">)(</span><span class="k">implicit</span> <span class="n">b2ordered</span><span class="k">:</span> <span class="kt">B</span> <span class="o">=></span> <span class="nc">Ordered</span><span class="o">[</span><span class="kt">B</span><span class="o">])</span><span class="k">:</span> <span class="kt">Boolean</span> <span class="kt">.</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala"> def <= [B >: A](that: B)(implicit b2ordered: B => Ordered[B]): Boolean . | |
| </code></pre></div> | |
| <p>Assume two lists <code>xs</code> and <code>ys</code> of type <code>List[Int]</code> | |
| and assume that the <code>list2ordered</code> and <code>int2ordered</code> | |
| methods defined <a href="#implicit-parameters">here</a> are in scope. | |
| Then the operation</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="n">xs</span> <span class="o"><=</span> <span class="n">ys</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala"> xs <= ys | |
| </code></pre></div> | |
| <p>is legal, and is expanded to:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"> <span class="n">list2ordered</span><span class="o">(</span><span class="n">xs</span><span class="o">)(</span><span class="n">int2ordered</span><span class="o">).<=</span> | |
| - <span class="o">(</span><span class="n">ys</span><span class="o">)</span> | |
| - <span class="o">(</span><span class="n">xs</span> <span class="k">=></span> <span class="n">list2ordered</span><span class="o">(</span><span class="n">xs</span><span class="o">)(</span><span class="n">int2ordered</span><span class="o">))</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala"> list2ordered(xs)(int2ordered).<= | |
| + (ys) | |
| + (xs => list2ordered(xs)(int2ordered)) | |
| </code></pre></div> | |
| <p>The first application of <code>list2ordered</code> converts the list | |
| <code>xs</code> to an instance of class <code>Ordered</code>, whereas the second | |
| @@ -388,11 +388,11 @@ | |
| <p>A method or class containing type parameters with view or context bounds is treated as being | |
| equivalent to a method with implicit parameters. Consider first the case of a | |
| single parameter with view and/or context bounds such as:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="nc">$f</span><span class="n">$</span><span class="o">[</span><span class="kt">$A$</span> <span class="k"><%</span> <span class="kt">$T_1$</span> <span class="kt">...</span> <span class="k"><%</span> <span class="kt">$T_m$</span> <span class="kt">:</span> <span class="kt">$U_1$</span> <span class="kt">:</span> <span class="kt">$U_n$</span><span class="o">](</span><span class="n">$</span><span class="o">\</span><span class="n">mathit</span><span class="o">{</span><span class="n">ps</span><span class="o">}</span><span class="n">$</span><span class="o">)</span><span class="k">:</span> <span class="kt">$R$</span> <span class="o">=</span> <span class="o">...</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">def $f$[$A$ <% $T_1$ ... <% $T_m$ : $U_1$ : $U_n$]($\mathit{ps}$): $R$ = ... | |
| </code></pre></div> | |
| <p>Then the method definition above is expanded to</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="nc">$f</span><span class="n">$</span><span class="o">[</span><span class="kt">$A$</span><span class="o">](</span><span class="n">$</span><span class="o">\</span><span class="n">mathit</span><span class="o">{</span><span class="n">ps</span><span class="o">}</span><span class="n">$</span><span class="o">)(</span><span class="k">implicit</span> <span class="nc">$v_1</span><span class="n">$</span><span class="k">:</span> <span class="kt">$A$</span> <span class="o">=></span> <span class="nc">$T_1</span><span class="n">$</span><span class="o">,</span> <span class="o">...,</span> <span class="nc">$v_m</span><span class="n">$</span><span class="k">:</span> <span class="kt">$A$</span> <span class="o">=></span> <span class="nc">$T_m</span><span class="n">$</span><span class="o">,</span> | |
| - <span class="nc">$w_1</span><span class="n">$</span><span class="k">:</span> <span class="kt">$U_1$</span><span class="o">[</span><span class="kt">$A$</span><span class="o">],</span> <span class="o">...,</span> <span class="nc">$w_n</span><span class="n">$</span><span class="k">:</span> <span class="kt">$U_n$</span><span class="o">[</span><span class="kt">$A$</span><span class="o">])</span><span class="k">:</span> <span class="kt">$R$</span> <span class="o">=</span> <span class="o">...</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">def $f$[$A$]($\mathit{ps}$)(implicit $v_1$: $A$ => $T_1$, ..., $v_m$: $A$ => $T_m$, | |
| + $w_1$: $U_1$[$A$], ..., $w_n$: $U_n$[$A$]): $R$ = ... | |
| </code></pre></div> | |
| <p>where the $v_i$ and $w_j$ are fresh names for the newly introduced implicit parameters. These | |
| parameters are called <em>evidence parameters</em>.</p> | |
| @@ -407,15 +407,15 @@ | |
| <p>Evidence parameters are prepended to the existing implicit parameter section, if one exists.</p> | |
| <p>For example:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="n">foo</span><span class="o">[</span><span class="kt">A:</span> <span class="kt">M</span><span class="o">](</span><span class="k">implicit</span> <span class="n">b</span><span class="k">:</span> <span class="kt">B</span><span class="o">)</span><span class="k">:</span> <span class="kt">C</span> | |
| -<span class="c1">// expands to: | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">def foo[A: M](implicit b: B): C | |
| +// expands to: | |
| // def foo[A](implicit evidence$1: M[A], b: B): C | |
| -</span></code></pre></div> | |
| +</code></pre></div> | |
| <h6 id="example">Example</h6> | |
| <p>The <code><=</code> method from the <a href="#example-ordered"><code>Ordered</code> example</a> can be declared | |
| more concisely as follows:</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">def</span> <span class="o"><=</span> <span class="o">[</span><span class="kt">B</span> <span class="k">>:</span> <span class="kt">A</span> <span class="k"><%</span> <span class="kt">Ordered</span><span class="o">[</span><span class="kt">B</span><span class="o">]](</span><span class="n">that</span><span class="k">:</span> <span class="kt">B</span><span class="o">)</span><span class="k">:</span> <span class="kt">Boolean</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">def <= [B >: A <% Ordered[B]](that: B): Boolean | |
| </code></pre></div> | |
| <h2 id="manifests">Manifests</h2> | |
| @@ -424,10 +424,10 @@ | |
| standard library contains a hierarchy of four manifest classes, | |
| with <code>OptManifest</code> | |
| at the top. Their signatures follow the outline below.</p> | |
| -<div class="highlight"><pre><code class="language-scala" data-lang="scala"><span class="k">trait</span> <span class="nc">OptManifest</span><span class="o">[</span><span class="kt">+T</span><span class="o">]</span> | |
| -<span class="nc">object</span> <span class="nc">NoManifest</span> <span class="k">extends</span> <span class="nc">OptManifest</span><span class="o">[</span><span class="kt">Nothing</span><span class="o">]</span> | |
| -<span class="k">trait</span> <span class="nc">ClassManifest</span><span class="o">[</span><span class="kt">T</span><span class="o">]</span> <span class="nc">extends</span> <span class="nc">OptManifest</span><span class="o">[</span><span class="kt">T</span><span class="o">]</span> | |
| -<span class="k">trait</span> <span class="nc">Manifest</span><span class="o">[</span><span class="kt">T</span><span class="o">]</span> <span class="nc">extends</span> <span class="nc">ClassManifest</span><span class="o">[</span><span class="kt">T</span><span class="o">]</span> | |
| +<div class="highlight"><pre><code class="language-scala" data-lang="scala">trait OptManifest[+T] | |
| +object NoManifest extends OptManifest[Nothing] | |
| +trait ClassManifest[T] extends OptManifest[T] | |
| +trait Manifest[T] extends ClassManifest[T] | |
| </code></pre></div> | |
| <p>If an implicit parameter of a method or constructor is of a subtype $M[T]$ of | |
| class <code>OptManifest[T]</code>, <em>a manifest is determined for $M[S]$</em>, |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment