<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Ion RA</title>
    <description>The latest articles on DEV Community by Ion RA (@ionra).</description>
    <link>https://dev.to/ionra</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F920255%2Fae7447cd-2a8e-4a3f-b829-645d0f9cffa0.jpeg</url>
      <title>DEV Community: Ion RA</title>
      <link>https://dev.to/ionra</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/ionra"/>
    <language>en</language>
    <item>
      <title>Rethinking Evidence in Scala 3: Concepts, Mechanisms, and Real‑World Engineering Impact</title>
      <dc:creator>Ion RA</dc:creator>
      <pubDate>Wed, 18 Nov 2026 21:48:41 +0000</pubDate>
      <link>https://dev.to/ionra/rethinking-evidence-in-scala-3-concepts-mechanisms-and-real-world-engineering-impact-10m4</link>
      <guid>https://dev.to/ionra/rethinking-evidence-in-scala-3-concepts-mechanisms-and-real-world-engineering-impact-10m4</guid>
      <description>&lt;p&gt;One of the most distinctive aspects of Scala 3 is the way it elevates the compiler from a conservative static checker into a powerful reasoning engine. With features like &lt;a href="https://docs.scala-lang.org/scala3/guides/macros/inline.html" rel="noopener noreferrer"&gt;&lt;strong&gt;inline computation&lt;/strong&gt;&lt;/a&gt;, &lt;a href="https://docs.scala-lang.org/scala3/guides/macros/macros.html" rel="noopener noreferrer"&gt;&lt;strong&gt;macros&lt;/strong&gt;&lt;/a&gt;, &lt;a href="https://docs.scala-lang.org/scala3/reference/new-types/match-types.html" rel="noopener noreferrer"&gt;&lt;strong&gt;match types&lt;/strong&gt;&lt;/a&gt;, and generally a more expressive system for &lt;a href="https://docs.scala-lang.org/scala3/reference/contextual/" rel="noopener noreferrer"&gt;&lt;strong&gt;contextual abstractions&lt;/strong&gt;&lt;/a&gt;, Scala 3 allows developers to push significant logic and validation into compile time, far beyond what mainstream languages such as &lt;strong&gt;Java&lt;/strong&gt;, &lt;strong&gt;C#&lt;/strong&gt; or &lt;strong&gt;Kotlin&lt;/strong&gt; could offer in their vanilla form.&lt;/p&gt;

&lt;p&gt;This technical facet doesn’t just change how programs are verified, it changes how they are written. Patterns that once required runtime checks using third-party libs or writing boilerplate can now be encoded as &lt;strong&gt;type‑level evidence&lt;/strong&gt;, guiding developers toward lighter, much more correct designs through the type system itself.&lt;/p&gt;

&lt;p&gt;Before diving in, let’s briefly outline what this lecture aims to uncover:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;We’ll examine how these capabilities for encoding evidence shape everyday coding practices, influence developer productivity and reasoning, and inform the broader engineering mindset, both at the application level and in the design of reusable libraries.&lt;/li&gt;
&lt;li&gt;More importantly, we’ll rethink what &lt;em&gt;evidence&lt;/em&gt; means in Scala 3 by exploring not only its canonical form (&lt;strong&gt;typeclass‑style contextual abstractions&lt;/strong&gt;), but also alternative mechanisms (such as &lt;strong&gt;runtime-assistance&lt;/strong&gt;, &lt;strong&gt;inline logic&lt;/strong&gt;, &lt;a href="https://docs.scala-lang.org/tour/pattern-matching.html#inner-main" rel="noopener noreferrer"&gt;&lt;strong&gt;pattern-matching&lt;/strong&gt;&lt;/a&gt;, and &lt;a href="https://docs.scala-lang.org/scala3/reference/metaprogramming/index.html" rel="noopener noreferrer"&gt;&lt;strong&gt;compile‑time metaprogramming&lt;/strong&gt;&lt;/a&gt;) for implementing the same idea.&lt;/li&gt;
&lt;li&gt;We’ll examine a meaningful categorization of the &lt;em&gt;evidence&lt;/em&gt; produced, and made visible, by the deeper structural patterns shared across these different implementation approaches.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F61ottfz6vb46yf53cqo8.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F61ottfz6vb46yf53cqo8.gif" alt="And so it begins" width="480" height="200"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  Evidence Categorization
&lt;/h2&gt;

&lt;p&gt;Our first step before we move deeper into the mechanisms themselves, it’s addressing the question of categorization. This comes in handy because once we begin examining how evidence is implemented in practice, a deeper pattern emerges, one that is helpful to recognize beforehand so you know what to expect and how to reason about it during code design and analysis.&lt;/p&gt;

&lt;p&gt;You see, evidence doesn’t influence Scala code in a single uniform way, instead, it manifests through two distinct modes of interaction that developers repeatedly encounter in both application‑level logic and library‑level design. These modes aren’t &lt;em&gt;official&lt;/em&gt; language constructs, but they arise naturally from how Scala 3’s type system &lt;em&gt;collaborates&lt;/em&gt; with the compiler and, at times, how it interacts with runtime information.&lt;/p&gt;

&lt;p&gt;Scala 3’s type system doesn’t merely describe programs, it actively participates in building and validating them. Once you begin relying on type‑level evidence (canonical or not), you encounter its influence in &lt;u&gt;two&lt;/u&gt; distinct ways during the act of writing Scala code. This happens whether or not the evidence operates purely at compile time or it also cooperates with runtime checks.&lt;/p&gt;

&lt;p&gt;So, without further ado, here they are:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;&lt;em&gt;Blocking&lt;/em&gt;&lt;/strong&gt; evidence 🛡️&lt;br&gt;
In most cases evidence is used in a defensive way, it acts as a barrier that prevents misuse.&lt;br&gt;
When a required piece of evidence cannot be &lt;a href="https://docs.scala-lang.org/scala3/reference/contextual/using-clauses.html" rel="noopener noreferrer"&gt;&lt;strong&gt;summoned&lt;/strong&gt;&lt;/a&gt;, the compiler stops you immediately.&lt;br&gt;
This mode of use protects APIs from being called with the wrong types, prevents incompatible abstractions from being combined, and enables enforcing domain rules directly at compile time.&lt;br&gt;
This is the &lt;u&gt;&lt;em&gt;stop right here&lt;/em&gt;&lt;/u&gt; form of evidence, development halts long before runtime.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;&lt;em&gt;Refinement&lt;/em&gt;&lt;/strong&gt; evidence 🔍&lt;br&gt;
This form of evidence is used constructively, it gives the compiler additional information so it can &lt;a href="https://medium.com/@markgrechanik/type-refinements-in-scala-making-your-types-more-sophisticated-than-your-friends-23600b2305d2" rel="noopener noreferrer"&gt;&lt;strong&gt;refine types&lt;/strong&gt;&lt;/a&gt; inside a block of code.&lt;br&gt;
Developers typically invoke it consciously to eliminate ambiguity, guide type inference, and enable precise logic.&lt;br&gt;
So in contrast to the other one, this evidence doesn’t block code, instead, it signals to the engineers, right in the flow of development, that they’re empowered to write logic the compiler can and will reason about more deeply.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Together, the blocking and refinement modes of evidence are part of those elements that shape the way Scala developers structure their code, design robust APIs, and express domain models with precision.&lt;/p&gt;




&lt;h2&gt;
  
  
  Scala's Mainstream Evidence
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvz4npcivnq57e6amdgjj.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvz4npcivnq57e6amdgjj.jpg" alt="Canonical Evidence Flexing" width="799" height="614"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;To get a better feel for type‑level evidence, let’s begin by taking a closer look at the well‑known &lt;code&gt;=:=&lt;/code&gt; class, the mainstream &lt;a href="https://github.com/scala/scala3/blob/eb198cfad4876e812699821583548e0730eaf051/library/src/scala/typeConstraints.scala#L206" rel="noopener noreferrer"&gt;&lt;strong&gt;equality evidence&lt;/strong&gt;&lt;/a&gt; which itself builds upon the &lt;code&gt;&amp;lt;:&amp;lt;&lt;/code&gt; class, the mainstream &lt;a href="https://github.com/scala/scala3/blob/eb198cfad4876e812699821583548e0730eaf051/library/src/scala/typeConstraints.scala#L64" rel="noopener noreferrer"&gt;&lt;strong&gt;subtype evidence&lt;/strong&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Scala’s &lt;code&gt;=:=&lt;/code&gt; type is the most popular tool for expressing blocking evidence. Its design is intentionally narrow and restrictive. Here are its main characteristics that define its purpose:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;p&gt;It is a &lt;a href="https://docs.scala-lang.org/tour/pattern-matching.html#sealed-types" rel="noopener noreferrer"&gt;&lt;strong&gt;sealed&lt;/strong&gt;&lt;/a&gt; &lt;a href="https://docs.scala-lang.org/scala3/book/domain-modeling-tools.html#abstract-classes" rel="noopener noreferrer"&gt;&lt;strong&gt;abstract&lt;/strong&gt;&lt;/a&gt; class, so users cannot extend or instantiate it.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Its &lt;a href="https://github.com/scala/scala3/blob/eb198cfad4876e812699821583548e0730eaf051/library/src/scala/typeConstraints.scala#L147" rel="noopener noreferrer"&gt;&lt;strong&gt;companion object&lt;/strong&gt;&lt;/a&gt;, inherited from &lt;code&gt;&amp;lt;:&amp;lt;&lt;/code&gt;, exposes only a singleton, presented through a controlled cast. So the only available evidence is the trivial &lt;code&gt;A =:= A&lt;/code&gt;, produced by the &lt;a href="https://github.com/scala/scala3/blob/eb198cfad4876e812699821583548e0730eaf051/library/src/scala/typeConstraints.scala#L169" rel="noopener noreferrer"&gt;&lt;code&gt;refl&lt;/code&gt; &lt;strong&gt;method&lt;/strong&gt;&lt;/a&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Because its type parameters are invariant, &lt;code&gt;A =:= B&lt;/code&gt; can only exist when A and B are exactly the same type.&lt;/p&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This design ensures that equality evidence is created exclusively by the compiler and only when the types genuinely match. If they do not, the evidence cannot be summoned and the call site fails immediately, basically the essence of "&lt;em&gt;blocking&lt;/em&gt;" behavior.&lt;/p&gt;




&lt;h2&gt;
  
  
  Applying Equality Evidence
&lt;/h2&gt;

&lt;blockquote&gt;
&lt;p&gt;Before we proceed, it’s worth noting that each of the concepts we’ll explore next will be grounded with small, concrete examples drawn from an &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus" rel="noopener noreferrer"&gt;&lt;strong&gt;application‑level project in the Passive‑haus domain&lt;/strong&gt;&lt;/a&gt;. These examples will help clarify how Scala’s compile‑time evidence works in practice and how it contrasts with more traditional approaches.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Imagine we’re modeling the thermal envelope of a passive house. One of the operations we might have to support is increasing the total insulation thickness by laminating together two insulation layers of the same kind.&lt;/p&gt;

&lt;p&gt;To begin, we need to define types for representing the structures of the issue we need to resolve and we need to define the unit types they'll be working with.&lt;/p&gt;

&lt;p&gt;As you move through the article, additional units will appear, and some of the existing types will gain new functionality and dependencies.&lt;/p&gt;

&lt;p&gt;For now, we'll start with a simple unit type used to represent insulation thickness. I’m introducing this one first so you can see what a &lt;strong&gt;simple&lt;/strong&gt; unit type looks like. Later, I’ll also show you how a &lt;strong&gt;compound&lt;/strong&gt; unit type is structured. To avoid cluttering the article with similar unit type definitions, I will show only one example of a simple unit type and one of a compound unit type. If you want to check out every unit type in full, including their operator‑based dependencies and other functionalities, you can find them all in the &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/units/LayerUnits.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;LayerUnits&lt;/strong&gt;&lt;/a&gt; file.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;scala&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;annotation&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;targetName&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="n"&gt;opaque&lt;/span&gt; &lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt;

    &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"meterApply"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;apply&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="nf"&gt;require&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="s2"&gt;"Length must be positive, got $value"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;value&lt;/span&gt;

    &lt;span class="n"&gt;extension&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"meterValue"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;

        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"meterMeterPlus"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;

        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"meterDoubleScalarProduct"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;scalar&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;scalar&lt;/span&gt;

        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"meterMeterGreaterThan"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;

        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"meterMeterLessThan"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;

    &lt;span class="n"&gt;extension&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;scalar&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"scalarMeterProduct"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;scalar&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;To keep our units grouped by domain specificity, organized and easy to import, we’ll create separate objects named after their respective domain areas, that expose only the units relevant to that part of the model. &lt;/p&gt;

&lt;p&gt;Through the rest of the project we'll import units through these domain‑focused export objects. These objects live in the same package as the unit definitions, but, for clarity, they’re located inside &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/units/UnitExtensions.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;UnitExtensions&lt;/strong&gt;&lt;/a&gt; file.&lt;/p&gt;

&lt;p&gt;Alright, here’s the code we have so far for this:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;LayerThickness&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;export&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
    &lt;span class="n"&gt;export&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Meter&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Next, in &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/materials/LayerMaterials.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;LayerMaterials&lt;/strong&gt;&lt;/a&gt; file we define the material types and the insulation representation:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;LayerThickness&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;trait&lt;/span&gt; &lt;span class="nc"&gt;Material&lt;/span&gt;

&lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt; &lt;span class="k"&gt;extends&lt;/span&gt; &lt;span class="nc"&gt;Material&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;WoodFiber&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;MineralWool&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Cellulose&lt;/span&gt;


&lt;span class="kd"&gt;final&lt;/span&gt; &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Insulation&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;thickness&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Now, inside &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/thermal/InsulationLamination.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;InsulationLamination&lt;/strong&gt;&lt;/a&gt;, let’s take a look at how we might implement the lamination operation using compile‑time evidence.&lt;/p&gt;

&lt;p&gt;Here is the type-level evidence‑based blocking version:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thermal&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;InsulationLamination&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;laminateLayers&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;
        &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="no"&gt;B&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;
    &lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;topLayer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Insulation&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;bottomLayer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Insulation&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;B&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;sameTypeEvidence&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;=:=&lt;/span&gt; &lt;span class="no"&gt;B&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Insulation&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="cm"&gt;/*
            Safe to proceed: in call-sites, reaching this point means the evidence has not blocked the flow 
            and it validated the type constraint at compile-time, so A == B is guaranteed.
        */&lt;/span&gt;
        &lt;span class="nc"&gt;Insulation&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt; 
            &lt;span class="n"&gt;material&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;topLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; 
            &lt;span class="n"&gt;thicknessM&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;topLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thicknessM&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;bottomLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thicknessM&lt;/span&gt;
        &lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;What advantages does this bring? Well:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The compiler enforces the constraint &lt;em&gt;A = B&lt;/em&gt; and guarantees it inside the guarded code-block&lt;/li&gt;
&lt;li&gt;No runtime checks are needed&lt;/li&gt;
&lt;li&gt;No reflection is involved&lt;/li&gt;
&lt;li&gt;Misuse is prevented during development, not after deployment&lt;/li&gt;
&lt;li&gt;The return type is exactly &lt;code&gt;Insulation[A]&lt;/code&gt;, preserving full type precision&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is the blocking role of type‑level evidence. It stops invalid states from being representable at all, enforcing correctness before the program can even run. And this is actually a pretty common way user-devs leverage evidence, so expect me to bring it up quite often 🙃. &lt;/p&gt;


&lt;h2&gt;
  
  
  Alternatives to Compile-Time Evidence
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzhuegvi7v163dzoccwb5.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzhuegvi7v163dzoccwb5.jpg" alt="Java haircuts" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Without any form of compile‑time evidence, there are essentially two broad approaches (both of which are basically just Java &lt;em&gt;haircuts&lt;/em&gt;, pretty standard baseline in Java‑style codebases 😉):&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Push all the responsibility onto the user of your code. This means the user of your API must manually ensure that the materials match before calling the function. This increases the cognitive load on every caller and makes misuse far more likely.&lt;/li&gt;
&lt;li&gt;Perform validation at runtime. In order to preserve the type information of the result, an &lt;a href="https://docs.scala-lang.org/scala3/book/types-adts-gadts.html" rel="noopener noreferrer"&gt;&lt;strong&gt;ADT&lt;/strong&gt;&lt;/a&gt; will be used to store that. This is safer than the first approach, but it introduces boilerplate, runtime overhead, and the possibility of late‑failing errors at the user side of the deal as in the end the result, be it a success or not, is passed to the user to handle. &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/thermal/InsulationLaminationRuntime.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;InsulationLaminationRuntime&lt;/strong&gt;&lt;/a&gt;, there is how such a version might look like:
&lt;/li&gt;
&lt;/ol&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thermal&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;runtime&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="cm"&gt;/*
    This ADT preserves type info. Although necessary given the situation, it adds complexity and boilerplate code.
*/&lt;/span&gt;
&lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="nc"&gt;LaminatedLayer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Success&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;layer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Insulation&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;MaterialMismatch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;top&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;bottom&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;InsulationLamination&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;laminateLayers&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;topLayer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Insulation&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="o"&gt;?&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;bottomLayer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Insulation&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="o"&gt;?&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;LaminatedLayer&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="cm"&gt;/*
            Runtime will support validation this time. Depending on the complexity of the constraints this could be 
            resource expensive, but it could also be relatively cheap if the constraints are simple and straight-forward.
        */&lt;/span&gt;
        &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;sameMaterialType&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="n"&gt;topLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;getClass&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;bottomLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;getClass&lt;/span&gt;

        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;sameMaterialType&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="cm"&gt;/*
                In here the responsibility for failure is passed down to the user.

                This could involve further use of logging and error handling logic in the application, which would
                make use of even more resources.

                This is susceptible to human error so it can pass by being unhandled or handled inappropriately.
            */&lt;/span&gt;
            &lt;span class="nc"&gt;LaminatedLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MaterialMismatch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
                &lt;span class="n"&gt;topLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                &lt;span class="n"&gt;bottomLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;
            &lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;else&lt;/span&gt;
            &lt;span class="cm"&gt;/*
                Type precision is retained through the ADT.
            */&lt;/span&gt;
            &lt;span class="nc"&gt;LaminatedLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Success&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
                &lt;span class="nc"&gt;Insulation&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
                    &lt;span class="n"&gt;material&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;topLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;asInstanceOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;topLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                    &lt;span class="n"&gt;thicknessM&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;topLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thicknessM&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;bottomLayer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thicknessM&lt;/span&gt;
                &lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Even in this small example, the difference in verbosity and clarity is obvious.&lt;/p&gt;

&lt;p&gt;So, let’s make clear once more why this version is inferior by briefly walking through the above applied example:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;If the developers are negligent, errors in the form of the mismatch case surface at runtime rather than compile time. They may or may not be caught in the testing phase. If not caught then they can propagate further, possibly leading to fail in production.&lt;/li&gt;
&lt;li&gt;Even simple checks, although cheap, rely on JVM class interrogation, and more complex ones may require full reflection.&lt;/li&gt;
&lt;li&gt;The return type in case of success recovers useful &lt;code&gt;Insulation&lt;/code&gt; type info, but is wrapped so is not directly usable.&lt;/li&gt;
&lt;li&gt;It requires considerably more boilerplate (about 45% more than the evidence based one).&lt;/li&gt;
&lt;li&gt;Comes with additional runtime performance costs.&lt;/li&gt;
&lt;li&gt;It's still less ergonomic compared to the compile-time evidence based example. More effort from the devs is required. The API is easy to misuse because neither the compiler nor the IDE can help you.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This should give you a foundational sense of why type‑level evidence is so valuable. And this is only the beginning, Scala’s evidence ecosystem extends far beyond the standard library’s &lt;code&gt;=:=&lt;/code&gt; and &lt;code&gt;&amp;lt;:&amp;lt;&lt;/code&gt;, encompassing mechanisms for both compile‑time guarantees and refinements, and sometimes even runtime‑assistance.&lt;/p&gt;



&lt;p&gt;As mentioned earlier, Scala’s evidence concept mechanisms are not limited to the &lt;em&gt;historical&lt;/em&gt; &lt;code&gt;=:=&lt;/code&gt; and &lt;code&gt;&amp;lt;:&amp;lt;&lt;/code&gt; witnesses that some books and the documentation often highlight. For starters, the standard library itself provide several additional constructs that act as &lt;em&gt;evidence&lt;/em&gt;, most of which serve as refinement tools, some purely at compile time, others with limited runtime participation. But only a small subset of these can be used in a blocking capacity, where not providing evidence prevents invalid code from being written.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;A few words on how tech books portray evidence: The thing is that many Scala texts do not treat this concept at all.&lt;br&gt;
Of those who do many do not treat it explicitly, neither theoretically nor as a unifying practical idea. Instead, often times, the discussion is brief and limited to the &lt;em&gt;historical&lt;/em&gt; forms such as &lt;code&gt;=:=&lt;/code&gt; and &lt;code&gt;&amp;lt;:&amp;lt;&lt;/code&gt;, as seen for example in the popular &lt;a href="https://horstmann.com/scala/" rel="noopener noreferrer"&gt;Scala for the Impatient by Cay S. Horstmann&lt;/a&gt; where chapter 19 (&lt;em&gt;Contextual Abstractions&lt;/em&gt;) addresses the concept of evidence... in a way, but subchapter 12 (&lt;em&gt;Evidence&lt;/em&gt;) being the most focused section on this topic within the entire chapter.&lt;br&gt;
However, it is worth noting that, by contrast, there is a book called &lt;a href="https://www.oreilly.com/library/view/programming-scala-3rd/9781492077886/" rel="noopener noreferrer"&gt;Programming Scala by Dean Wampler&lt;/a&gt; that takes a more flexible and thorough approach on this subject. In the chapter &lt;em&gt;Abstracting Over Context: Using Clauses&lt;/em&gt;, particularly from the subsection &lt;em&gt;Constraining Allowed Instances&lt;/em&gt; up to the end of the chapter, the book illustrates several different ways the idea of evidence can be implemented beyond Scala 3’s canonical style. This makes it one of the few resources that, although not explicitly, approaches &lt;em&gt;evidence&lt;/em&gt; as a broader conceptual pattern rather than a single feature.&lt;br&gt;
As for what the future holds, there is one more book that at the time of writing this it has not yet been released, but there are chances that it may approach the topic of evidence similar to how Wampler did it. This book is called &lt;a href="https://www.artima.com/shop/advanced_programming_in_scala_5ed" rel="noopener noreferrer"&gt;Advanced Programming in Scala by Martin Odersky&lt;/a&gt;, the creator of Scala. While the published table of contents does not explicitly mention the concept of &lt;em&gt;evidence&lt;/em&gt;, it does appear to explore many of the advanced alternative mechanisms for representing this idea.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;As we will explore later on, in the broader Scala 3 feature landscape, for these blocking and refining roles it does seem very much to be the case that they can also be fulfilled by inline checks, match‑type reductions, and macro‑generated proofs. Together, these mechanisms support both safe API design and expressive, type‑directed logic.&lt;/p&gt;

&lt;p&gt;So, now that we’ve contrasted compile‑time equality evidence with its runtime alternatives in the insulation lamination example, we may very well continue on the Scala standard library path and showcase the other major evidence constructs that reside in there. These tools, whether used to enforce constraints or refine types, they play a central role in the realistic passive-house domain modeling and in any domain where correctness is encoded directly into the type system.&lt;/p&gt;

&lt;p&gt;As a heads-up, we will look at:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://github.com/scala/scala3/blob/eb198cfad4876e812699821583548e0730eaf051/library/src/scala/reflect/ClassTag.scala#L53" rel="noopener noreferrer"&gt;&lt;strong&gt;ClassTag&lt;/strong&gt;&lt;/a&gt; -&amp;gt; runtime type retention&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/scala/scala3/blob/eb198cfad4876e812699821583548e0730eaf051/library/src/scala/deriving/Mirror.scala#L49" rel="noopener noreferrer"&gt;&lt;strong&gt;Mirror.Of&lt;/strong&gt;&lt;/a&gt; -&amp;gt; structural guarantees for generic meta-programming&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/scala/scala3/blob/eb198cfad4876e812699821583548e0730eaf051/library/src/scala/ValueOf.scala#L57" rel="noopener noreferrer"&gt;&lt;strong&gt;ValueOf&lt;/strong&gt;&lt;/a&gt; -&amp;gt; literal/singleton type evidence&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://dotty.epfl.ch/docs/internals/gadts.html" rel="noopener noreferrer"&gt;&lt;strong&gt;GADTs&lt;/strong&gt;&lt;/a&gt; and &lt;strong&gt;sealed hierarchies&lt;/strong&gt; -&amp;gt; compiler‑driven type refinement in pattern matching&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So, tighten-up your belts as we are going for a ride :)&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4txaclgwx29c4988cnoe.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4txaclgwx29c4988cnoe.gif" alt="Get ready" width="200" height="200"&gt;&lt;/a&gt;&lt;/p&gt;


&lt;h2&gt;
  
  
  ClassTag as Refinement
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;ClassTag&lt;/code&gt; can be used to implement a form of refinement evidence that operates with runtime assistance. Unlike purely compile‑time evidence, it bridges a gap created by JVM type erasure, meaning that it preserves the runtime class of a type parameter that would otherwise disappear.&lt;/p&gt;

&lt;p&gt;This preserved runtime information allows the compiler to maintain coherence between compile‑time refinements and runtime behavior. When the developer writes a pattern match on an erased type, the compiler rewrites that match into a &lt;code&gt;ClassTag&lt;/code&gt;‑based check. The refinement logic expressed in the code remains valid because the runtime now has enough information to verify it.&lt;/p&gt;

&lt;p&gt;Let's put it this way, &lt;code&gt;ClassTag&lt;/code&gt; enables type‑directed operations that would be impossible under JVM erasure alone. It does not block invalid code at compile time, but, instead, it empowers the developer to write precise logic that the compiler can safely narrow and enforce at runtime. Hence the refinement nature for this evidence.&lt;/p&gt;

&lt;p&gt;To see this refinement role in action, consider how &lt;code&gt;ClassTag&lt;/code&gt; enables safe retrieval of materials of a particular passive-house certified kind from a &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/repository/MaterialRepository.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;MaterialRepository&lt;/strong&gt;&lt;/a&gt;.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;repository&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;scala&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;reflect&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ClassTag&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="kd"&gt;final&lt;/span&gt; &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;MaterialRepository&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Vector&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Material&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;add&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Material&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;MaterialRepository&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="nf"&gt;copy&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;materials&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="cm"&gt;/*
        Only allows retrieving materials of a particular certified type.
    */&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;certifiedOnly&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="nc"&gt;ClassTag&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Vector&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="cm"&gt;/*
            The ClassTag acts as an enabler: it gives the compiler enough runtime type
            information to perform a meaningful type test even after JVM erasure. The
            compiler rewrites the pattern match to use this retained runtime class, so
            the match is both valid and safe.

            Developers coding this kind of evidence are aware that inside the case body the 
            value is guaranteed to be of type T &amp;lt;: A, so they can write the case body knowingly
        */&lt;/span&gt;
        &lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;collect&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;material&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Mirror.Of as Blocker and Refinement
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;Mirror.Of&lt;/code&gt; is a compile‑time evidence mechanism whose primary role is refinement but which also naturally acts as a blocker. It exposes the structural shape of a type to the compiler, allowing it to reason about product and sum types without any runtime reflection. All derivation happens at compile time, and the resulting evidence enables precise, type‑oriented logic inside generic code while also preventing certain methods (through the &lt;code&gt;using&lt;/code&gt; clause) from being called on types that lack the required structure.&lt;/p&gt;

&lt;p&gt;To see both the refinement and blocking roles in action, consider how &lt;code&gt;Mirror.Of&lt;/code&gt; lets us validate insulation specifications generically. By inspecting the compile‑time structure of the type, we can enforce passive‑house domain rules with minimal runtime assistance, only a small amount of reflection is needed when &lt;code&gt;ClassTag&lt;/code&gt; participates. The essential logic, however, is driven entirely by compile‑time evidence.&lt;/p&gt;

&lt;p&gt;In here, more unit types will make their presence, among them the base unit &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/units/LayerUnits.scala#L146" rel="noopener noreferrer"&gt;&lt;strong&gt;Ratio&lt;/strong&gt;&lt;/a&gt; and two compound units, &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/units/LayerUnits.scala#L250" rel="noopener noreferrer"&gt;&lt;strong&gt;KgPerCubicMeter&lt;/strong&gt;&lt;/a&gt; and &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/units/LayerUnits.scala#L325" rel="noopener noreferrer"&gt;&lt;strong&gt;WattsPerSquareMeterKelvin&lt;/strong&gt;&lt;/a&gt; (which, because of how they’re composed, will in turn require defining a few additional base and compound units).&lt;/p&gt;

&lt;p&gt;Since earlier we looked at a simple unit type, this is a good moment to also show how a compound one is structured. As an example, here is the definition of &lt;code&gt;WattsPerSquareMeterKelvin&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="cm"&gt;/* ... */&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="n"&gt;opaque&lt;/span&gt; &lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt;

    &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;Watt&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Watt&lt;/span&gt;
    &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;SquareMeter&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;SquareMeter&lt;/span&gt;
    &lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;Kelvin&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Kelvin&lt;/span&gt;

    &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"wsmkApply"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;apply&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="nf"&gt;require&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="s2"&gt;"U-value must be positive, got $value"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;value&lt;/span&gt;

    &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"wsmkFromWattSqmKelvin"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;from&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;power&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Watt&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;area&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;SquareMeter&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;deltaT&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Kelvin&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="nf"&gt;apply&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;power&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;area&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;deltaT&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="n"&gt;extension&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;u&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"wsmkValue"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;u&lt;/span&gt;

        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"wsmkWsmkPlus"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;u&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;

        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"wsmkScalarProduct"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;scalar&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;u&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;scalar&lt;/span&gt;

        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"wsmkWsmkGreaterThan"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;u&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;

        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"wsmkWsmkLessThan"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;other&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;u&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="n"&gt;other&lt;/span&gt;

    &lt;span class="n"&gt;extension&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;scalar&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="nd"&gt;@targetName&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"scalarWsmkProduct"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;u&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;u&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;scalar&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;And then &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/units/UnitExtensions.scala#L22" rel="noopener noreferrer"&gt;&lt;strong&gt;WindowUValue&lt;/strong&gt;&lt;/a&gt;, the appropriate export object:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="cm"&gt;/* ... */&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;WindowUValue&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;export&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
    &lt;span class="n"&gt;export&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Next, inside &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/thermal/specs/InsulationSpec.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;InsulationSpec&lt;/strong&gt;&lt;/a&gt; let's define an ADT that captures a sealed hierarchy of insulation specs:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thermal&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;specs&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;LayerDensity&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WindowGValue&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WindowUValue&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;LayerThickness&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Material&lt;/span&gt;

&lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="nc"&gt;InsulationSpec&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;ExteriorFacade&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Material&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;thickness&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;density&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;KgPerCubicMeter&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Window&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;uValue&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;gValue&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Ratio&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;And now for the &lt;em&gt;slightly more elaborate&lt;/em&gt; part 😉. Here are the effects that &lt;code&gt;Mirror.Of&lt;/code&gt;, specifically through its &lt;strong&gt;Product&lt;/strong&gt; mirror, has on &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/validators/PassivhausSpecValidator.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;PassivhausSpecValidator&lt;/strong&gt;&lt;/a&gt;:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;validators&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Material&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thermal&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;specs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;InsulationSpec&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thermal&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;specs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;InsulationSpec&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;scala&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;deriving&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Mirror&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;scala&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;compiletime&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;erasedValue&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;summonInline&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;scala&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;reflect&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ClassTag&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;LayerThickness&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;LayerDensity&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WindowGValue&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WindowUValue&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;PassivhausSpecValidator&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="cm"&gt;/*
        This example happens to have a second layer of evidence which are these field rules.
        As you probably figured it out by now this is a blocking type evidence.
        The main evidence, which is the catalyst for this second layer, is still the Mirror.
    */&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;trait&lt;/span&gt; &lt;span class="nc"&gt;PassivhausFieldRule&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="nc"&gt;PassivhausFieldRule&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;with&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.25&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="nc"&gt;PassivhausFieldRule&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;KgPerCubicMeter&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;with&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;d&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;KgPerCubicMeter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="n"&gt;d&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;KgPerCubicMeter&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;15&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="nc"&gt;PassivhausFieldRule&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;with&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;u&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="n"&gt;u&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.85&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="nc"&gt;PassivhausFieldRule&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ratio&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;with&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;g&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Ratio&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="n"&gt;g&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="nc"&gt;Ratio&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.5&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="nc"&gt;PassivhausFieldRule&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Material&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;with&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Material&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;isInstanceOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="nc"&gt;PassivhausFieldRule&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Any&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;with&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Any&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;


    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validateExteriorFacadeSpec&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ExteriorFacade&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;validateInline&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validateWindowSpec&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Window&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;validateInline&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="cm"&gt;/*
        The Mirror.ProductOf[A] parameter is evidence that A is a product type 
        with compiler-known structure. If A has no mirror, this method cannot 
        even be called. This is the blocking role of Mirror. It prevents 
        misuse by rejecting types that do not have structural information.
    */&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validateInline&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;InsulationSpec&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Mirror&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ProductOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;

        &lt;span class="cm"&gt;/* 
            Once the mirror exists, the inline match below uses it as refinement
            evidence. 

            The inline match forces the compiler to reduce the match at 
            compile time. Because m is a Mirror.ProductOf[A], the compiler 
            knows exactly which case applies for the concrete A at the call 
            site. This collapses the generic A into a specific domain type.
            This is the refinement role of Mirror. It exposes the structure 
            of A so the compiler can route the logic statically.
        */&lt;/span&gt;
        &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Mirror&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ProductOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;ExteriorFacade&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt;
                &lt;span class="nf"&gt;validateExteriorFacade&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;asInstanceOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;ExteriorFacade&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Mirror&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ProductOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Window&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt;
                &lt;span class="nf"&gt;validateWindowInsulation&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;asInstanceOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Window&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nf"&gt;validateGeneric&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="cm"&gt;/* 
        Specialized paths for known domain shapes. These are selected entirely at compile time via the mirror refinement.
    */&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validateExteriorFacade&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ExteriorFacade&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="n"&gt;validateFields&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;
            &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Material&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;KgPerCubicMeter&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;fromProductTyped&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validateWindowInsulation&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Window&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="n"&gt;validateFields&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;
            &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;WattsPerSquareMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Ratio&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;fromProductTyped&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="cm"&gt;/*  
        Generic fallback, this one uses the mirror to extract the tuple of field types.
    */&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validateGeneric&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Product&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Mirror&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ProductOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="n"&gt;validateFields&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MirroredElemTypes&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;fromProductTyped&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;spec&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="cm"&gt;/*  
        The recursion is unrolled at compile-time thanks to the inline match, erasedValue and
        the specialized literal type tuple resulted from the Mirror refinement
    */&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validateFields&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Elems&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;values&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Elems&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;erasedValue&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Elems&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;EmptyTuple&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;

            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt;
                &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;fields&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;values&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;asInstanceOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
                &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;fields&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;head&lt;/span&gt;
                &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;tail&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;fields&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tail&lt;/span&gt;

                &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;ok&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;summonInline&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;PassivhausFieldRule&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;h&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;head&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

                &lt;span class="n"&gt;ok&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;validateFields&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tail&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;In the validator, &lt;code&gt;Mirror.ProductOf[A]&lt;/code&gt; plays its roles as blocker and refinement very clearly. By requiring a mirror as a contextual parameter, the validator immediately gains a compile‑time gate (if a type has no mirror because it is not a case class, tuple, or any compiler‑generated product then the call is ill‑typed and rejected).&lt;br&gt;
That is the blocking aspect, the mirror serves as structural evidence that must exist before the method is even callable.&lt;/p&gt;

&lt;p&gt;Once that evidence is available, the mirror’s refinement power takes over. The &lt;a href="https://docs.scala-lang.org/scala3/guides/macros/inline.html#inline-matches" rel="noopener noreferrer"&gt;&lt;strong&gt;inline match&lt;/strong&gt;&lt;/a&gt; on the mirror lets the compiler collapse the abstract &lt;code&gt;A&lt;/code&gt; into one of the known domain shapes (&lt;code&gt;ExteriorFacade&lt;/code&gt;, &lt;code&gt;Window&lt;/code&gt;) or fall back to a generic path. This branching is resolved entirely at compile time, with no runtime reflection. From there, &lt;code&gt;m.MirroredElemTypes&lt;/code&gt; exposes the exact field types, enabling the compiler to unroll the tuple and specialize the validation logic for each component.&lt;/p&gt;

&lt;p&gt;The &lt;code&gt;PassivhausFieldRule&lt;/code&gt; typeclass then builds on what the mirror reveals. For each field type in the tuple, &lt;code&gt;summonInline&lt;/code&gt; selects the appropriate rule at compile time. If no rule exists, the code fails to compile, if it does, the rule’s logic is inlined directly into the unrolled recursion. But all of this is downstream of the mirror. As for the inlines, we'll talk more about them in a later chapter.&lt;br&gt;
The mirror is both the admission ticket and the structural description. It allows the type into the system and refines it into a shape the compiler can reason about.&lt;/p&gt;

&lt;p&gt;You see, in this way, &lt;code&gt;Mirror.ProductOf&lt;/code&gt; is both a gate and a lens. It blocks types that don’t belong, and for those that do, it lets the compiler see deeply enough into their structure to drive precise, domain‑specific validation, and all of it entirely at compile time.&lt;/p&gt;


&lt;h2&gt;
  
  
  ValueOf as Blocker and Refinement
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;ValueOf&lt;/code&gt; is another promising mechanism for achieving compile‑time evidence. This one links a &lt;a href="https://docs.scala-lang.org/sips/42.type.html#introduction" rel="noopener noreferrer"&gt;&lt;strong&gt;literal-based singleton type&lt;/strong&gt;&lt;/a&gt; (let's call it just &lt;em&gt;literal type&lt;/em&gt;) to its corresponding runtime value. When a type parameter is a literal type, such as "WF" or "MW", the compiler can automatically provide a &lt;code&gt;ValueOf[T]&lt;/code&gt; instance that reifies that literal type into an actual value. This allows literal‑driven logic to be expressed without manually passing values around, while not just preserving strong compile‑time guarantees, but also enabling them even more.&lt;/p&gt;

&lt;p&gt;Although &lt;code&gt;ValueOf&lt;/code&gt; is resolved entirely at compile time, its effects reverberate into runtime. Much like &lt;code&gt;ClassTag&lt;/code&gt;, which carries erased type information forward into runtime operations, &lt;code&gt;ValueOf&lt;/code&gt; carries the literal value forward into runtime logic. The difference is that &lt;code&gt;ValueOf&lt;/code&gt; does not recover erased types, instead, it materializes the value of a literal type. This gives it a dual nature. It is primarily compile‑time evidence, yet it also has a direct and meaningful runtime footprint.&lt;/p&gt;

&lt;p&gt;To see how &lt;code&gt;ValueOf&lt;/code&gt; supports compile‑time blocking and refinement, consider how literal‑typed material codes can drive passive‑house lookup logic, ensuring that only certified materials can ever be referenced in configuration or thermal‑performance calculations.&lt;/p&gt;

&lt;p&gt;But first . . .&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0i1fupp2d1le8tl90ldz.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0i1fupp2d1le8tl90ldz.jpg" alt="I am once again asking for adding a new unit type" width="748" height="611"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Don't worry, it's only one this time ;) and as I mentioned earlier, I won't take up extra space by listing its implementation here.&lt;/p&gt;

&lt;p&gt;More precisely, this is where you’ll encounter the compound unit type &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/units/LayerUnits.scala#L287" rel="noopener noreferrer"&gt;&lt;strong&gt;WPerMeterKelvin&lt;/strong&gt;&lt;/a&gt; and its export object &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/units/UnitExtensions.scala#L17" rel="noopener noreferrer"&gt;&lt;strong&gt;ThermalConductivity&lt;/strong&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Ok, now we can design the &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/materials/lookup/MaterialLambdaLookup.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;MaterialLambdaLookup&lt;/strong&gt;&lt;/a&gt; like this:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;lookup&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;scala&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;compiletime&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="n"&gt;erasedValue&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;constValue&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;error&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ThermalConductivity&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="cm"&gt;/*
    MaterialCode is part of the domain’s ubiquitous language. 
    Encoding the allowed codes as literal types ensures that only 
    valid codes can ever appear in the system. No runtime validation
    is needed, the type system enforces correctness.
*/&lt;/span&gt;
&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nc"&gt;MaterialCode&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="s2"&gt;"WF"&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s2"&gt;"MW"&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s2"&gt;"CL"&lt;/span&gt;

&lt;span class="cm"&gt;/*
    ValueOf[Code] is evidence that Code is a literal type whose 
    value is known at compile time. This evidence has two effects:
    1. Compile-time blocking: the compiler cannot construct a 
    MaterialTag unless Code is a literal type. Dynamic strings 
    or unknown codes simply cannot be used. 
    2. Runtime reverberation: unlike purely compile-time evidence 
    (e.g., Mirror), ValueOf reifies the literal type into an 
    actual runtime value. This allows the literal identity of 
    the material code to be used in domain objects, logging, 
    serialization and so on.
*/&lt;/span&gt;
&lt;span class="kd"&gt;final&lt;/span&gt; &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;MaterialTag&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;MaterialCode&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;valueOfCode&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ValueOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;code&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;valueOfCode&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;

&lt;span class="cm"&gt;/* 
    This given auto-derives tags using ValueOf evidence. 
    Basically, the compiler materializes the literal value automatically.
*/&lt;/span&gt;
&lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;materialTag&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;MaterialCode&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ValueOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;MaterialTag&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="nc"&gt;MaterialTag&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="cm"&gt;/* 
    ValueOf is used indirectly in here, it is the reason Code is guaranteed
    to be a literal type, thus enabling erasedValue-based branching.
*/&lt;/span&gt;
&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;MaterialLambdaLookup&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;materialFor&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;MaterialCode&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;erasedValue&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"WF"&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WoodFiber&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"MW"&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MineralWool&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"CL"&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Cellulose&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nf"&gt;error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Unhandled material code! Separate implementation is worth considering."&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;lambdaFor&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;MaterialCode&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;erasedValue&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"WF"&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.040&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"MW"&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.036&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"CL"&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.038&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nf"&gt;error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Unhandled material code! Separate implementation is worth considering."&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="cm"&gt;/* 
        constValue[Code] retrieves the literal value of Code at compile time. 
        This is only possible because ValueOf evidence exists for Code. 
        The comparison `code == constValue[Code]` is reduced statically, 
        eliminating all runtime branching.
    */&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;lambdaTable&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"WF"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.040&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt;
        &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"MW"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.036&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt;
        &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"CL"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.038&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt;
        &lt;span class="nc"&gt;EmptyTuple&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;lookupLambda&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;MaterialCode&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;table&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;table&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;EmptyTuple&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt;
                &lt;span class="nf"&gt;error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Invalid material code. It's unreachable due to type constraints."&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;code&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="n"&gt;tail&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt;
                &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;code&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;constValue&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="n"&gt;then&lt;/span&gt; &lt;span class="n"&gt;value&lt;/span&gt;
                    &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="n"&gt;lookupLambda&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="n"&gt;href&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"tail"&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;/&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt;

    &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;lambdaForViaTable&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;MaterialCode&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="n"&gt;lookupLambda&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;lambdaTable&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;In the &lt;em&gt;Passivhaus&lt;/em&gt; material lookup system, &lt;code&gt;ValueOf&lt;/code&gt; opens up room to explore how literal‑based mechanisms might serve as forms of evidence beyond the canonical ones, while in this case playing both roles from the evidence role categorization we’ve been using.&lt;/p&gt;

&lt;p&gt;First, it acts as a compile‑time gatekeeper, the blocking role. Any function that requires a &lt;code&gt;ValueOf[Code]&lt;/code&gt; can only be called with a literal type argument. If a caller attempts to pass a non‑literal type or a dynamically computed string, the compiler cannot produce the evidence, and the call is rejected. This prevents invalid material codes from ever entering the system and ensures that all lookups are statically verified.&lt;/p&gt;

&lt;p&gt;Second, &lt;code&gt;ValueOf&lt;/code&gt; acts as a refinement mechanism. Once the compiler has established that a literal type is in scope, the evidence exposes its exact value to inline logic. This enables functions like &lt;code&gt;lambdaFor&lt;/code&gt; and &lt;code&gt;materialFor&lt;/code&gt; to branch on the literal type using &lt;a href="https://docs.scala-lang.org/scala3/reference/metaprogramming/compiletime-ops.html#erasedvalue" rel="noopener noreferrer"&gt;&lt;code&gt;erasedValue&lt;/code&gt;&lt;/a&gt; or compare it against tuple entries using &lt;a href="https://docs.scala-lang.org/scala3/reference/metaprogramming/compiletime-ops.html#constvalue-and-constvalueopt" rel="noopener noreferrer"&gt;&lt;code&gt;constValue&lt;/code&gt;&lt;/a&gt;. Because the literal value is available at compile time, the compiler can reduce these branches statically, eliminating all runtime conditionals. Yet the reified value is still present at runtime, allowing the literal identity of the material code to be used in, for example: logging, tagging, or domain objects such as &lt;code&gt;MaterialTag&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;As you can see, having &lt;em&gt;evidence&lt;/em&gt; 😉 that &lt;code&gt;ValueOf&lt;/code&gt; can act both as a goalkeeper and a midfielder makes it a powerful tool for domains where literal identifiers carry real semantic meaning.&lt;/p&gt;


&lt;h2&gt;
  
  
  GADTs as Blocking Evidence
&lt;/h2&gt;

&lt;p&gt;GADTs can serve as blocking evidence by encoding domain constraints directly into the type system. Instead of validating combinations at runtime, the type parameter of a GADT acts as evidence that a particular operation is only meaningful for certain variants. When the type parameter does not match, the program becomes ill‑typed, and the compiler blocks the invalid combination before it can even be expressed.&lt;/p&gt;

&lt;p&gt;Now, how to apply this in our passive‑house example? We will do it using &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/installation/MaterialInstaller.scala#L16" rel="noopener noreferrer"&gt;installation methods&lt;/a&gt; that should not be universally applicable. Certain materials can only be installed using specific techniques. By encoding each installation method as a GADT case indexed by the material kind it supports, we ensure that only valid (material, method) combinations are representable. Attempting to pair a material with an incompatible installation method fails at compile time. The GADT’s type parameter becomes the evidence that the method is appropriate for the material, and the absence of matching evidence prevents invalid operations from being written at all.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;installation&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;

&lt;span class="cm"&gt;/* 
    Each constructor fixes the type parameter M to the only material that
    supports that installation method. This fixed type parameter is a compile‑time proof.

    Because the constructor itself carries this proof, the compiler can reject
    any attempt to use an installation method with a material whose singleton
    type does not match the constructor’s fixed M.

    The GADT therefore restricts the space of legal installation methods to the
    known cases, and each case encodes its own validity conditions.
*/&lt;/span&gt;
&lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="nc"&gt;InstallMethod&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Stapled&lt;/span&gt;   &lt;span class="k"&gt;extends&lt;/span&gt; &lt;span class="nc"&gt;InstallMethod&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MineralWool&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;BlownIn&lt;/span&gt;   &lt;span class="k"&gt;extends&lt;/span&gt; &lt;span class="nc"&gt;InstallMethod&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Cellulose&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;PressFit&lt;/span&gt;  &lt;span class="k"&gt;extends&lt;/span&gt; &lt;span class="nc"&gt;InstallMethod&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WoodFiber&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;MaterialInstaller&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="cm"&gt;/* 
        The install method requires that the material and the method share the same
        type parameter M. Because each GADT constructor fixes M to a specific
        material, only valid combinations can satisfy this requirement.

        For example:
        install(material = Cellulose, withMethod = Stapled)   // rejected at compile time
        install(material = MineralWool, withMethod = Stapled) // accepted

        No runtime checks are needed. The GADT’s type parameter is the evidence,
        and the method signature forces the compiler to respect it.

        Illegal states are not representable.
    */&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;install&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;withMethod&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;InstallMethod&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Unit&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="nb"&gt;println&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="s2"&gt;"Installing ${material} using $withMethod"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Here, invalid combinations simply cannot be written.&lt;br&gt;
The compiler blocks them before the program can run.&lt;/p&gt;


&lt;h2&gt;
  
  
  GADTs as Refinement Evidence
&lt;/h2&gt;

&lt;p&gt;When a GADT constructor fixes its type parameter, pattern matching on a value of that GADT automatically narrows the type in each branch.&lt;/p&gt;

&lt;p&gt;In the context of a passive‑house insulation layer, this means:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;once you match on a &lt;code&gt;Layer[M]&lt;/code&gt;,&lt;/li&gt;
&lt;li&gt;the compiler knows exactly which certified material is present,&lt;/li&gt;
&lt;li&gt;and it refines M to that material’s singleton type.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Because &lt;code&gt;LayerData&lt;/code&gt; is also parameterized by M, this refinement flows into the data it carries. Inside each branch, the compiler now knows the precise material type stored in &lt;code&gt;data.material&lt;/code&gt;, enabling material‑specific operations that would not be legal on the general &lt;code&gt;PassivhausCertifiedMaterial&lt;/code&gt; supertype.&lt;/p&gt;

&lt;p&gt;This refinement is entirely static.&lt;br&gt;
No runtime type tests, no casting, no &lt;code&gt;isInstanceOf&lt;/code&gt;.&lt;br&gt;
The GADT constructor itself is the evidence that drives the narrowing.&lt;/p&gt;

&lt;p&gt;For our pilot project, this is especially useful in building‑physics calculations. Each certified material has a known thermal conductivity (λ‑value), and the R‑value of a layer is computed as &lt;code&gt;R = thickness / lambda&lt;/code&gt;. Some materials also require material‑specific corrections (compression, moisture expansion, settling), and these adjustments are only available once the type has been refined.&lt;/p&gt;

&lt;p&gt;By refining the material type in each match branch, the compiler guarantees that:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;the λ‑value and correction factors correspond to the correct certified material&lt;/li&gt;
&lt;li&gt;all certified materials are handled exhaustively&lt;/li&gt;
&lt;li&gt;no unapproved or unknown material can slip into the calculation&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;So inside &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/layers/LayerData.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;LayerData&lt;/strong&gt;&lt;/a&gt; you can see how all of that looks like in code:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;layers&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MaterialCorrections&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;LayerThickness&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ThermalConductivity&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;units&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ThermalResistance&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="cm"&gt;/*
    LayerData carries the physical parameters needed for thermal calculations.

    It is generic in M so that the material field preserves the refined type.
    This is essential: when a Layer[M] is pattern‑matched, the compiler refines M
    to a specific singleton type (e.g., MineralWool.type). Because LayerData
    stores the material as M, the refined type flows into data.material as well.

    This allows material‑specific operations (compressionFactor, settlingFactor,
    etc.) to become available only in the branches where the compiler knows the
    exact material type.

    λ (lambda) is the thermal conductivity of the material.
    R‑value = thickness / lambda --- standard building‑physics practice.
*/&lt;/span&gt;
&lt;span class="kd"&gt;final&lt;/span&gt; &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;LayerData&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;thickness&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Meter&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;lambda&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WPerMeterKelvin&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="cm"&gt;/*
    Layer is a GADT whose constructors refine the material type.

    Each constructor fixes the type parameter M to the singleton type of the
    certified material it represents:

        WoolLayer      : Layer[MineralWool.type]
        FiberLayer     : Layer[WoodFiber.type]
        CelluloseLayer : Layer[Cellulose.type]

    Because LayerData is also parameterized by M, the refined type flows into
    the data it carries. Inside each match branch, the compiler knows the exact
    material type, enabling material‑specific operations that would otherwise be
    illegal on the general PassivhausCertifiedMaterial supertype.

    This is compile‑time refinement: no runtime checks, no casting.
    The GADT constructors themselves are the refinement evidence.
*/&lt;/span&gt;
&lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;WoolLayer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;LayerData&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;MineralWool&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;extends&lt;/span&gt; &lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;MineralWool&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;FiberLayer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;LayerData&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;WoodFiber&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
       &lt;span class="k"&gt;extends&lt;/span&gt; &lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;WoodFiber&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;CelluloseLayer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;LayerData&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Cellulose&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
       &lt;span class="k"&gt;extends&lt;/span&gt; &lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Cellulose&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="cm"&gt;/*
    computeAdjustedRValue demonstrates refinement‑driven specialization.

    Pattern matching on Layer[M] refines M to a specific singleton type.
    Because LayerData stores its material as M, the refined type flows into
    data.material as well.

    This enables calling material‑specific correction factors:

        • MineralWool.type    → compressionFactor
        • WoodFiber.type      → moistureExpansionFactor
        • Cellulose.type      → settlingFactor

    These extension methods are not available on the general
    PassivhausCertifiedMaterial type. They only become legal inside the
    corresponding match branch because the GADT has refined M.

    This is the essence of GADT refinement: new operations become available
    precisely because the compiler now knows the exact material type.
*/&lt;/span&gt;
&lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;computeAdjustedRValue&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;layer&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;RSquareMeterKelvinPerWatt&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;layerData&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;correctionFactor&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;layer&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
        &lt;span class="c1"&gt;// M is refined to MineralWool.type&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WoolLayer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;compressionFactor&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

        &lt;span class="c1"&gt;// M is refined to WoodFiber.type&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;FiberLayer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;moistureExpansionFactor&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

        &lt;span class="c1"&gt;// M is refined to Cellulose.type&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;CelluloseLayer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;data&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;material&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;settlingFactor&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;adjustedThickness&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;layerData&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;thickness&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;correctionFactor&lt;/span&gt;

    &lt;span class="nc"&gt;RSquareMeterKelvinPerWatt&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;from&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;adjustedThickness&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;layerData&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;lambda&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;blockquote&gt;
&lt;p&gt;As for the material corrections themselfs, for the sake of brevity, these values are expressed here as hardcoded literals, even though in a real production scenario they would most likely come from vendor‑supplied material data. Since the goal is to illustrate an alternative evidence mechanism rather than model the full data pipeline, this simplified form it should do for now.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Inside &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/materials/MaterialCorrections.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;MaterialCorrections&lt;/strong&gt;&lt;/a&gt; you can find how those corrections look like in code:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;MaterialCorrections&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="n"&gt;extension&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;MineralWool&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;compressionFactor&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mf"&gt;0.97&lt;/span&gt;   &lt;span class="c1"&gt;// wool compresses slightly&lt;/span&gt;

    &lt;span class="n"&gt;extension&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;WoodFiber&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;moistureExpansionFactor&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mf"&gt;1.02&lt;/span&gt;   &lt;span class="c1"&gt;// wood fiber swells a bit&lt;/span&gt;

    &lt;span class="n"&gt;extension&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;m&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Cellulose&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;settlingFactor&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Double&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mf"&gt;0.95&lt;/span&gt;      &lt;span class="c1"&gt;// cellulose settles over time&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;As you can see, inside each branch, the compiler knows exactly which material type is in play.&lt;br&gt;
No runtime type tests are needed, the refinement is entirely static.&lt;/p&gt;


&lt;h2&gt;
  
  
  Composed Custom Evidence
&lt;/h2&gt;

&lt;p&gt;Scala’s type system allows developers to express constraints far richer than what the standard library’s built‑in evidence mechanisms can offer on their own. With enums, sealed traits, match types, and recursive typeclasses, we can encode domain‑specific rules directly into the type system itself. Basically, at this point, evidence becomes more than a safety net, it becomes a modeling tool.&lt;/p&gt;

&lt;p&gt;Up to this point, our evidence types have mostly answered a simple and very short chain of yes/no questions: &lt;em&gt;"Are these two types equal? Is this type a subtype of that one? Has this GADT branch refined the type parameter?"&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;These are powerful tools, but they all share one comoomon thing, they are single boolean checks or refinements.&lt;/p&gt;

&lt;p&gt;But, many times in production we will find that a more complex and many-factor dependant check-up is required. For example, we may very well want to say &lt;em&gt;"Given this material and this assembly type, run a series of checks and, if everything passes, treat the result as a validated assembly of layers."&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;This is no longer a simple and tiny chain of yes/no questions. It is a type‑level computation of many factors.&lt;/p&gt;

&lt;p&gt;As we have done with the other concepts so far let's implement this in our pilot project.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fk6uyjwn9v1x134hjh1fr.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fk6uyjwn9v1x134hjh1fr.jpg" alt="Moisture Compatible Situation" width="800" height="454"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;We begin by defining inside the &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/assembly/constraints/moisture/MoistureCompatible.scala" rel="noopener noreferrer"&gt;&lt;strong&gt;MoistureCompatible&lt;/strong&gt;&lt;/a&gt; file type‑level functions (&lt;a href="https://docs.scala-lang.org/scala3/reference/new-types/type-lambdas-spec.html" rel="noopener noreferrer"&gt;&lt;strong&gt;type lambdas&lt;/strong&gt;&lt;/a&gt;) that classify both materials and assemblies according to their moisture behavior. &lt;code&gt;MaterialMoistureTolerance&lt;/code&gt; assigns a moisture‑tolerance class to each material and &lt;code&gt;AssemblyMoistureRisk&lt;/code&gt; assigns a moisture‑risk class to each assembly type. These are then composed into a third type‑level function, &lt;code&gt;MoistureCompatible&lt;/code&gt;, that compares the two and yields a &lt;code&gt;Boolean&lt;/code&gt; at the type level.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;constraints&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;moisture&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;AssemblyType&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;enum&lt;/span&gt; &lt;span class="nc"&gt;MoistureRisk&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Low&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Medium&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;High&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nc"&gt;MoistureRisk&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="cm"&gt;/*
    AssemblyMoistureRisk[A] is a type‑level function that assigns a moisture
    risk class to each assembly type.
*/&lt;/span&gt;
&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nc"&gt;AssemblyMoistureRisk&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;MoistureRisk&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;ExteriorWall&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;High&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;InteriorWall&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;Medium&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;BelowGradeWall&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;High&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;

&lt;span class="cm"&gt;/*
    MaterialMoistureTolerance[M] is a type‑level function that assigns a moisture
    tolerance class to each certified material.
*/&lt;/span&gt;
&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nc"&gt;MaterialMoistureTolerance&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;MoistureRisk&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;MineralWool&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;High&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;WoodFiber&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;Medium&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="nc"&gt;Cellulose&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;Low&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;

&lt;span class="cm"&gt;/*
    MoistureCompatible[M, A] is a type‑level Boolean that encodes whether
    the material’s tolerance is sufficient for the assembly’s moisture risk.

    This is a multi-factor type‑level computation:
    1. compute MaterialMoistureTolerance[M]
    2. compute AssemblyMoistureRisk[A]
    3. compare the two and yield true or false
*/&lt;/span&gt;
&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nc"&gt;MoistureCompatible&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="kt"&gt;Boolean&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;MaterialMoistureTolerance&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;AssemblyMoistureRisk&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;High&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;High&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;High&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Medium&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;High&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Low&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Medium&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Medium&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Medium&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Low&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Low&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Low&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
        &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;  &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;blockquote&gt;
&lt;p&gt;Note that this &lt;code&gt;Boolean&lt;/code&gt; value isn’t written manually. It’s computed by the compiler from the domain rules encoded in the match types above. In a production system, these rules wouldn’t be hardcoded at the type level, they would likely originate from an external specification service and be parsed at runtime. The compiler cannot consume that runtime data directly, obviosuly, but the encodings type lambdas, match types, and the surrounding ADTs would need to mirror the structure of the richer domain model described by the external spec. In this example, as with others before it, we keep the domain intentionally small and hardcode the rules so we can focus on the mechanics of the type‑level multi-factor computation itself.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Once the type lambda &lt;code&gt;MoistureCompatible[M, A]&lt;/code&gt; computes to a &lt;code&gt;Boolean&lt;/code&gt;, we need a way to turn that &lt;code&gt;Boolean&lt;/code&gt; into evidence the compiler can actually use. That role is played by the evidence type &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/validators/AssemblyValidator.scala#L31" rel="noopener noreferrer"&gt;&lt;code&gt;AssemblyMemberValidator[M, A]&lt;/code&gt;&lt;/a&gt;. Its only instance provider is the &lt;code&gt;validateMaterialAssembly&lt;/code&gt; given, which becomes available only if the compiler can prove all the required type‑level checks, in our case is only that &lt;code&gt;MoistureCompatible[M, A] =:= true&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;If the type‑level computation yields false, the compiler cannot construct &lt;code&gt;AssemblyMemberValidator[M, A]&lt;/code&gt;, and the pair (M, A) becomes uninhabited. In other words, no value of that combination can ever exist. This is how invalid (material, assembly) pairs are ruled out at compile time through type‑level computation.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;validators&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;materials&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;AssemblyType&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;constraints&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;moisture&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MoistureRisk&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;constraints&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;moisture&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MoistureRisk&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;constraints&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;moisture&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MaterialMoistureTolerance&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;constraints&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;moisture&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;AssemblyMoistureRisk&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;constraints&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;moisture&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MoistureCompatible&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;layers&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Layer&lt;/span&gt;


&lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;AssemblyValidator&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="cm"&gt;/*
        AssemblyMemberValidator[M, A] is a custom evidence type.

        A value of this type is a proof that the combination of a group member, M, and an
        AssemblyType, A, has passed all type‑level checks (for now we have only the moisture 
        compatibility check, other checks could be added later on as necessary for the domain logic).

        The key point: we do not enumerate all (M, A) pairs manually. Instead, we compute whether
        a given combination (M, A) is valid using the match types for moisture risk.
    */&lt;/span&gt;
    &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;validators&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;sealed&lt;/span&gt; &lt;span class="k"&gt;trait&lt;/span&gt; &lt;span class="nc"&gt;AssemblyMemberValidator&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

    &lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;validators&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;AssemblyMemberValidator&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="cm"&gt;/*
            This given is only available when MoistureCompatible[M, A] is true.

            The constraint is enforced by requiring evidence that
            MoistureCompatible[M, A] =:= true.

            If the type‑level computation MoistureCompatible[M, A] yields false,
            the compiler cannot construct this given, and therefore no
            AssemblyMemberValidator[M, A] exists.
        */&lt;/span&gt;
        &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;validateMaterialAssembly&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt;
            &lt;span class="n"&gt;moistureCompatibility&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;MoistureCompatible&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=:=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
        &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyMemberValidator&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;AssemblyMemberValidator&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;This still is evidence in the traditional sense! Why? Because it blocks invalid states and refines what the program knows. But at this stage the evidence is no longer a simple, straight-forward safety check, it’s the outcome of a multi‑step, domain‑specific computation. The type system isn’t merely validating types, it’s enforcing the Passivhaus moisture‑compatibility rules encoded in &lt;code&gt;MaterialMoistureTolerance&lt;/code&gt;, &lt;code&gt;AssemblyMoistureRisk&lt;/code&gt;, and &lt;code&gt;MoistureCompatible&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Now, an assembly consists of multiple layers, right? So we need evidence for every material in the stack. To achieve that, we introduce a recursive typeclass, &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/validators/AssemblyValidator.scala#L56" rel="noopener noreferrer"&gt;&lt;code&gt;AssemblyValidatorOf&lt;/code&gt;&lt;/a&gt;, as part of the broader &lt;code&gt;AssemblyValidator&lt;/code&gt; tools. It walks the tuple one element at a time, ensuring that each layer satisfies the required constraints.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="c1"&gt;// . . .&lt;/span&gt;

&lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;AssemblyValidator&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

&lt;span class="c1"&gt;// . . .&lt;/span&gt;

    &lt;span class="cm"&gt;/*
        This is a recursive typeclass that walks the tuple of layers and requires
        AssemblyMemberValidator[M, A] for each material M of each layer.
        Later on, this could also be extended (as it's necessary for the domain logic) to include givens
        for different groups, not only layers of materials (for example, it can cover a Tuple of
        technologies specific to a particular AssemblyType).
    */&lt;/span&gt;
    &lt;span class="k"&gt;sealed&lt;/span&gt; &lt;span class="k"&gt;trait&lt;/span&gt; &lt;span class="nc"&gt;AssemblyValidatorOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ts&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

    &lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;AssemblyValidatorOf&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

        &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;emptyAssembly&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyValidatorOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;EmptyTuple&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;AssemblyValidatorOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;EmptyTuple&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

        &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;validateLayersAssembly&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;
            &lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="nc"&gt;Tail&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyType&lt;/span&gt;
        &lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt;
            &lt;span class="nc"&gt;AssemblyMemberValidator&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="nc"&gt;AssemblyValidatorOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Tail&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
        &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyValidatorOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="nc"&gt;Tail&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;AssemblyValidatorOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="nc"&gt;Tail&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;The empty tuple is always valid. A non‑empty tuple is valid only if its head layer’s material has an &lt;code&gt;AssemblyValidator&lt;/code&gt; for the chosen assembly type, and the tail of the tuple is itself validated by another instance of &lt;code&gt;AssemblyValidatorOf&lt;/code&gt;. This recursive structure ensures that every material in the tuple satisfies the moisture‑compatibility rules.&lt;/p&gt;

&lt;p&gt;Another recursive typeclass is &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/assembly/layers/LayersOfMaterialsAssembly.scala#L18" rel="noopener noreferrer"&gt;&lt;code&gt;AllMaterials&lt;/code&gt;&lt;/a&gt;. This ensures that the tuple contains only layers whose material types are certified Passivhaus materials.&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="c1"&gt;// . . .&lt;/span&gt;

&lt;span class="cm"&gt;/*
    This is a recursive typeclass that walks a tuple of layers and ensures that each
    element is a Layer[M] where M &amp;lt;: PassivhausCertifiedMaterial.
*/&lt;/span&gt;
&lt;span class="k"&gt;trait&lt;/span&gt; &lt;span class="nc"&gt;AllMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ts&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;AllMaterials&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;emptyMaterialLayersTuple&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;AllMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;EmptyTuple&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;AllMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;EmptyTuple&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;validateLayersOfPCM&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;
        &lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="nc"&gt;Tail&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;
    &lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt;
        &lt;span class="nc"&gt;AllMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Tail&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;AllMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="nc"&gt;Tail&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;AllMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="nc"&gt;Tail&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Together, &lt;code&gt;AllMaterials&lt;/code&gt; and &lt;code&gt;AssemblyValidatorOf&lt;/code&gt; guarantee that the layer stack is both structurally well‑formed and moisture‑compatible.&lt;/p&gt;

&lt;p&gt;And now, when it comes to the actual construction of a moisture-compatible layer assembly we will define two ways through which to do it:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;directly through the inner factory &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/assembly/layers/LayersOfMaterialsAssembly.scala#L79" rel="noopener noreferrer"&gt;&lt;code&gt;AssemblyFactory&lt;/code&gt;&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;or through the factory method &lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus/blob/master/src/main/scala/envelope/assembly/layers/LayersOfMaterialsAssembly.scala#L69" rel="noopener noreferrer"&gt;&lt;code&gt;LayersOfMaterialsAssembly.make&lt;/code&gt;&lt;/a&gt; which eventually passes the control to the inner factory. This method is more for aiding type inference of the two type params the factory requires, thus making the call site for the creation of the assembly a bit more cleaner.
&lt;/li&gt;
&lt;/ol&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;passivhaus&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;envelope&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;layers&lt;/span&gt;

&lt;span class="c1"&gt;// . . .&lt;/span&gt;

&lt;span class="cm"&gt;/*
    This LayersOfMaterials type lambda maps a tuple of material types Ms into a tuple of
    Layer[M &amp;amp; PassivhausCertifiedMaterial] types (a type intersection which,
    in this case, in practice resumes to Layer[M] types).

    It is used internally to store the layers inside the LayersOfMaterialsAssembly case class.
*/&lt;/span&gt;
&lt;span class="k"&gt;private&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;assembly&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nc"&gt;LayersOfMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ms&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kt"&gt;Map&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ms&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;M&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;


&lt;span class="kd"&gt;final&lt;/span&gt; &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;LayersOfMaterialsAssembly&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ms&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;layers&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;LayersOfMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ms&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="cm"&gt;/*
        As you already saw with the Layer class, here too, in LayersOfMaterialsAssembly,
        we define a method of calculating the adjusted R value, only that this time
        it's the collective R values
    */&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;totalAdjustedRValue&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;RSquareMeterKelvinPerWatt&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="n"&gt;layers&lt;/span&gt;
            &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;toList&lt;/span&gt;
            &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;asInstanceOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kt"&gt;List&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Layer&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;PassivhausCertifiedMaterial&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
            &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;map&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;computeAdjustedRValue&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;reduce&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;



&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;LayersOfMaterialsAssembly&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

    &lt;span class="cm"&gt;/* 
        Mainly used for type param inference aid.
    */&lt;/span&gt;
    &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;make&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyFactory&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;AssemblyFactory&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

    &lt;span class="cm"&gt;/*
        The apply method is enabling the multi-factor evidence. Mainly two 
        type-level computations.

        Both of wich are recursive typeclasses that walk the tuple of layers
        and ensure that all required evidence exists.
    */&lt;/span&gt;
    &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;AssemblyFactory&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;AssemblyType&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;

        &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;apply&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ts&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;layers&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Ts&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt;
            &lt;span class="nc"&gt;AllMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ts&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="nc"&gt;AssemblyValidatorOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ts&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
        &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;LayersOfMaterialsAssembly&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ts&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
            &lt;span class="nc"&gt;LayersOfMaterialsAssembly&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;layers&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;asInstanceOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;LayersOfMaterials&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Ts&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Either way the compiler must satisfy both &lt;code&gt;AllMaterials&lt;/code&gt; and &lt;code&gt;AssemblyValidatorOf&lt;/code&gt;. This means the compiler must:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Infer the tuple of materials from the provided layers.&lt;/li&gt;
&lt;li&gt;Confirm that each element of the tuple is a valid &lt;code&gt;Layer[M]&lt;/code&gt; for some certified material M.&lt;/li&gt;
&lt;li&gt;Compute &lt;code&gt;MaterialMoistureTolerance&lt;/code&gt; for each material in the tuple.&lt;/li&gt;
&lt;li&gt;Compute &lt;code&gt;AssemblyMoistureRisk&lt;/code&gt; for the chosen assembly type.&lt;/li&gt;
&lt;li&gt;Evaluate &lt;code&gt;MoistureCompatible&lt;/code&gt; for each material–assembly pair.&lt;/li&gt;
&lt;li&gt;Construct &lt;code&gt;AssemblyMemberValidator&lt;/code&gt; for each material where compatibility holds.&lt;/li&gt;
&lt;li&gt;Recursively assemble these into &lt;code&gt;AssemblyValidatorOf&lt;/code&gt; for the entire tuple.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If any of these steps fail, if even one material is incompatible with the assembly type, the compiler cannot construct the required evidence, and the assembly cannot be expressed in the program.&lt;/p&gt;

&lt;p&gt;This is a compile‑time guarantee that the assembly respects the Passivhaus moisture‑compatibility rules. In this case we only have one compatibility rule, but many others can be added like sound absorption, load-bearing capacity, and so on.&lt;/p&gt;

&lt;p&gt;Basically, the type system becomes an active participant in enforcing building‑physics constraints.&lt;/p&gt;



&lt;p&gt;Alright, look. This could be a bit mentally draining, but since you’ve made it this far, for sure you're not someone that gives up easily.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2l4o1ihqpp6jgrwg6kvm.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2l4o1ihqpp6jgrwg6kvm.gif" alt="Brothority" width="640" height="640"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;So... let's recap what we showcased in this chapter :)&lt;/p&gt;

&lt;p&gt;At this point, type‑evidence‑driven design has fully crossed into domain modeling. We are no longer using the type system merely to avoid mistakes or catch trivial errors. Instead, we are using it to encode the logic of the domain itself.&lt;/p&gt;

&lt;p&gt;The combination of &lt;code&gt;MaterialMoistureTolerance&lt;/code&gt;, &lt;code&gt;AssemblyMoistureRisk&lt;/code&gt;, &lt;code&gt;MoistureCompatible&lt;/code&gt;, &lt;code&gt;AssemblyMemberValidator&lt;/code&gt;, &lt;code&gt;AssemblyValidatorOf&lt;/code&gt;, and &lt;code&gt;AllMaterials&lt;/code&gt; forms a type‑level rule engine. The compiler evaluates these rules every time an assembly is constructed. The result is a system where invalid states are not just discouraged, they are impossible to represent (yes, I know I’ve said this a few times already, but come on, it’s such a gloriously Thanos‑level move. We basically, during the development stage, just snapped them out of existence 🙃).&lt;/p&gt;

&lt;p&gt;This is the essence of type‑evidence‑driven design! The program becomes a faithful reflection of the domain, and the compiler becomes a validator of domain rules. The developer is guided toward correct constructions not by documentation or runtime checks, but by the structure of the type system itself.&lt;/p&gt;

&lt;p&gt;Now, it’s worth noting that there are several ways to express the composition logic behind typeclass evidence. These other approaches typically involve &lt;code&gt;inline&lt;/code&gt; definitions, &lt;a href="https://docs.scala-lang.org/scala3/guides/macros/compiletime.html#summoning" rel="noopener noreferrer"&gt;summon&lt;/a&gt; based methods, and, when the most amount of liberty and &lt;em&gt;power&lt;/em&gt; is needed, devs could make use of &lt;a href="https://docs.scala-lang.org/scala3/guides/macros/macros.html" rel="noopener noreferrer"&gt;macros&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;So far, we’ve looked at Scala 3’s approach to evidence within the context of an application-level project. In the following chapters, we’ll examine these mechanisms through two real‑world library projects that make heavy use of them. More precisely through &lt;a href="https://github.com/typelevel/shapeless-3" rel="noopener noreferrer"&gt;Shapeless 3&lt;/a&gt; and &lt;a href="https://github.com/softwaremill/tapir" rel="noopener noreferrer"&gt;Tapir&lt;/a&gt;. As they provide excellent, practical examples of how inline matching and summon-based derivation come together to build sophisticated typeclass derivation systems. And also, in the context of macro-based composition, we will take a glimpse in the &lt;a href="https://github.com/zio" rel="noopener noreferrer"&gt;ZIO&lt;/a&gt; library ecosystem as well.&lt;/p&gt;


&lt;h2&gt;
  
  
  Designing Compound Custom Evidence Using Inlines and Summons
&lt;/h2&gt;

&lt;p&gt;In the previous chapter we noted that Scala offers several ways to express the composition logic behind typeclass evidence. Now, the inline definitions, summon‑based methods, and, when the most freedom is needed, macros, all of these provide complementary mechanisms for building compound custom evidence.&lt;/p&gt;

&lt;p&gt;Previously we designed evidence on an application-level, in this chapter, we will briefly experience the library-level design with inlines and summons, more precisely we turn to two real‑world libraries that rely heavily on these other approaches. The particular areas we'll examine are &lt;strong&gt;Shapeless‑3&lt;/strong&gt;'s kinds derivation and &lt;strong&gt;Tapir&lt;/strong&gt;'s Iron integration. They offer concrete, production‑tested examples of how inline matching and summon‑based derivation can be used to assemble sophisticated evidence structures.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Before starting to get the ball rolling, it helps to clarify two ideas that will appear repeatedly:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Calling summon methods, like &lt;a href="https://nightly.scala-lang.org/docs/reference/metaprogramming/compiletime-ops.html#summoninline" rel="noopener noreferrer"&gt;&lt;code&gt;summonInline&lt;/code&gt;&lt;/a&gt; it's still considered as applying evidence! It is not that different from a &lt;code&gt;using&lt;/code&gt; clause. The only difference is that you can request the evidence inside a method body, inside a branch, or inside a recursive function. This gives you more control over when and how evidence is pulled into scope.&lt;/li&gt;
&lt;li&gt;An &lt;a href="https://docs.scala-lang.org/scala3/reference/metaprogramming/inline.html#transparent-vs-non-transparent-inline" rel="noopener noreferrer"&gt;inline given&lt;/a&gt; is a given whose body is expanded at compile time. This allows the compiler to inspect the structure of types, pattern‑match on them, and choose derivation paths dynamically.&lt;/li&gt;
&lt;/ol&gt;
&lt;/blockquote&gt;


&lt;h3&gt;
  
  
  Inline‑driven Compound Evidence in Shapeless‑3
&lt;/h3&gt;

&lt;p&gt;Let's start with a concise definition. Shapeless‑3 is a generic programming library that provides automatic derivation of typeclass instances.&lt;/p&gt;

&lt;p&gt;Good! Now, for this example, we'll take a look inside the &lt;a href="https://github.com/typelevel/shapeless-3/blob/main/modules/deriving/src/main/scala/shapeless3/deriving/kinds.scala" rel="noopener noreferrer"&gt;kinds.scala&lt;/a&gt; file, which contains several pieces of code that illustrate how the library uses inline derivation to assemble compound evidence. The goal here is not to describe the entire file, but to highlight a few representative snippets where this pattern becomes visible.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/typelevel/shapeless-3/blob/main/modules/deriving/src/main/scala/shapeless3/deriving/kinds.scala#L128" rel="noopener noreferrer"&gt;One such piece&lt;/a&gt; is a recursive match type:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;  &lt;span class="cm"&gt;/** Applies `F` to all elements of the tuple type `T`. Similar to [[Tuple.Map]] but generalized to this kind. */&lt;/span&gt;
  &lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nc"&gt;LiftP&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Up&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tup&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Mono&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Head&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="nc"&gt;LiftP&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Tail&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;EmptyTuple&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;&lt;code&gt;LiftP&lt;/code&gt; does not produce evidence by itself. Instead, it describes the shape of the evidence that later definitions will construct: one &lt;code&gt;F[...]&lt;/code&gt; for each component of a tuple.&lt;br&gt;
It is a type‑level helper that participates in the composition process.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/typelevel/shapeless-3/blob/main/modules/deriving/src/main/scala/shapeless3/deriving/kinds.scala#L137" rel="noopener noreferrer"&gt;Elsewhere in the file&lt;/a&gt;, two inline givens make use of this helper:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;  &lt;span class="cm"&gt;/** Given a [[scala.deriving.Mirror.Product]], provides instances of the type class `F` for all fields of `T`. */&lt;/span&gt;
  &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;mkProductInstances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Up&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Up&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;gen&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Mirror&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Product&lt;/span&gt; &lt;span class="n"&gt;of&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ProductInstances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="nc"&gt;ErasedProductInstances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;LiftP&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;gen&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MirroredElemTypes&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;gen&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

  &lt;span class="cm"&gt;/** Given a [[scala.deriving.Mirror.Sum]], provides instances of the type class `F` for all variants of `T`. */&lt;/span&gt;
  &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;mkCoproductInstances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Up&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Up&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;gen&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Mirror&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Sum&lt;/span&gt; &lt;span class="n"&gt;of&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;CoproductInstances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="nc"&gt;ErasedCoproductInstances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;self&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;LiftP&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;gen&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MirroredElemTypes&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;gen&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;These &lt;code&gt;given&lt;/code&gt; definitions illustrate how Shapeless turns the type‑level structure described by &lt;code&gt;LiftP&lt;/code&gt; into value‑level evidence. Each receives a structural mirror (&lt;code&gt;Mirror.Product&lt;/code&gt; or &lt;code&gt;Mirror.Sum&lt;/code&gt;), computes the tuple of evidence types via &lt;code&gt;LiftP&lt;/code&gt;, and wraps the result into a domain‑specific structure. If any component instance is missing, the blocking hopes in and so the derivation fails.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/typelevel/shapeless-3/blob/main/modules/deriving/src/main/scala/shapeless3/deriving/kinds.scala#L133" rel="noopener noreferrer"&gt;A third piece of code&lt;/a&gt; shows how Shapeless selects between these two definitions:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;  &lt;span class="cm"&gt;/** Given a [[scala.deriving.Mirror]], provides instances of the type class `F` for all fields or variants of `T`. */&lt;/span&gt;
  &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;mkInstances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Up&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Up&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;gen&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Mirror&lt;/span&gt; &lt;span class="n"&gt;of&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Instances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;gen&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Mirror&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Product&lt;/span&gt; &lt;span class="n"&gt;of&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;mkProductInstances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;Mirror&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Sum&lt;/span&gt; &lt;span class="n"&gt;of&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;mkCoproductInstances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;This inline given acts as a dispatcher. It inspects the structure of T through its mirror and chooses the appropriate constructor.&lt;br&gt;
The composition logic is quite visible in here. The structure of the type determines which evidence is assembled.&lt;/p&gt;

&lt;p&gt;And finally, the file also exposes &lt;a href="https://github.com/typelevel/shapeless-3/blob/main/modules/deriving/src/main/scala/shapeless3/deriving/kinds.scala#L119" rel="noopener noreferrer"&gt;the appliance&lt;/a&gt; of the &lt;code&gt;mkInstances&lt;/code&gt; evidence provider:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;  &lt;span class="cm"&gt;/** Summon instances of the type class `F` for all fields or variants of the type `T`. */&lt;/span&gt;
  &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nc"&gt;Instances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Up&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Up&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;inst&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Instances&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;F&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;inst&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;inst&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Requesting &lt;code&gt;Instances[F, T]&lt;/code&gt; triggers the chain of inline givens. The compiler resolves the &lt;code&gt;using&lt;/code&gt; clause by expanding &lt;code&gt;mkInstances&lt;/code&gt;, which delegates to the appropriate branch and ultimately constructs the composite evidence described by &lt;code&gt;LiftP&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Again, these snippets do not represent the entire purpose of the file, but they offer a clear view of how Shapeless uses inline matching and type‑level helpers to assemble compound evidence.&lt;/p&gt;


&lt;h3&gt;
  
  
  Summon‑driven Compound Evidence in Tapir-Iron
&lt;/h3&gt;

&lt;p&gt;Tapir's Iron integrtion uses refinement types into Tapir’s schema and validation system. The file &lt;a href="https://github.com/softwaremill/tapir/blob/master/integrations/iron/src/main/scala/sttp/iron/codec/iron/TapirCodecIron.scala" rel="noopener noreferrer"&gt;TapirCodecIron.scala&lt;/a&gt; contains several places where summon‑based derivation is used to build compound evidence.&lt;/p&gt;

&lt;p&gt;Again, the goal here is not to describe the entire file, but to observe a few representative examples.&lt;/p&gt;

&lt;p&gt;One such example is a recursive function, &lt;a href="https://github.com/softwaremill/tapir/blob/master/integrations/iron/src/main/scala/sttp/iron/codec/iron/TapirCodecIron.scala#L131" rel="noopener noreferrer"&gt;&lt;code&gt;summonValidators&lt;/code&gt;&lt;/a&gt;, that gathers per‑predicate validators:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;  &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;summonValidators&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;A&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;:&lt;/span&gt; &lt;span class="nc"&gt;Tuple&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;List&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;ValidatorForPredicate&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Any&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;erasedValue&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;match&lt;/span&gt;
      &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;EmptyTuple&lt;/span&gt;     &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="nc"&gt;Nil&lt;/span&gt;
      &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;head&lt;/span&gt; &lt;span class="o"&gt;*:&lt;/span&gt; &lt;span class="n"&gt;tail&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt;
        &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;headValidator&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ValidatorForPredicate&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;?&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;summonFrom&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
          &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;pv&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;PrimitiveValidatorForPredicate&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sb"&gt;`head`&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;pv&lt;/span&gt;
          &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;                                             &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;summonInline&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;ValidatorForPredicate&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;head&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="n"&gt;headValidator&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;asInstanceOf&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;ValidatorForPredicate&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Any&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;::&lt;/span&gt; &lt;span class="n"&gt;summonValidators&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tail&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;This function inspects the tuple of predicates A. For each head, it attempts to obtain a primitive validator, if none is available, it falls back to &lt;code&gt;summonInline[ValidatorForPredicate[N, head]]&lt;/code&gt;.&lt;br&gt;
Each call to &lt;code&gt;summonInline&lt;/code&gt; is an application of evidence.&lt;br&gt;
Eventually, the recursion accumulates a list of validators, one for each predicate.&lt;/p&gt;

&lt;p&gt;In another snippet, the &lt;a href="https://github.com/softwaremill/tapir/blob/master/integrations/iron/src/main/scala/sttp/iron/codec/iron/TapirCodecIron.scala#L142" rel="noopener noreferrer"&gt;&lt;code&gt;given validatorForAnd&lt;/code&gt;&lt;/a&gt; is presented. Here it is shown how these validators are combined when the predicate is an intersection:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;  &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;validatorForAnd&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Predicates&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="n"&gt;mirror&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;IntersectionTypeMirror&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Predicates&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ValidatorForPredicate&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Predicates&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;ValidatorForPredicate&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Predicates&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;

      &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;intersectionConstraint&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;Constraint&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;IntersectionConstraint&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Predicates&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
      &lt;span class="kd"&gt;val&lt;/span&gt; &lt;span class="n"&gt;validatorsForPredicates&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;List&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;ValidatorForPredicate&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Any&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;summonValidators&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;mirror&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ElementTypes&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

      &lt;span class="k"&gt;override&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;validator&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Validator&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Validator&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;all&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;validatorsForPredicates&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;map&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;validator&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

      &lt;span class="k"&gt;override&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;makeErrors&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;errorMessage&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;List&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;ValidationError&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="o"&gt;?&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;intersectionConstraint&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;test&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;value&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
          &lt;span class="kt"&gt;List&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
            &lt;span class="nc"&gt;ValidationError&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;N&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
              &lt;span class="nc"&gt;Validator&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Custom&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt;
                &lt;span class="nc"&gt;ValidationResult&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Invalid&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;intersectionConstraint&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;message&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="c1"&gt;// at this point the validator is already failed anyway&lt;/span&gt;
              &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
              &lt;span class="n"&gt;value&lt;/span&gt;
            &lt;span class="p"&gt;)&lt;/span&gt;
          &lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="nc"&gt;Nil&lt;/span&gt;

    &lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;This &lt;code&gt;inline given&lt;/code&gt; applies only when &lt;code&gt;Predicates&lt;/code&gt; is an intersection type, enforced by &lt;code&gt;IntersectionTypeMirror&lt;/code&gt;. It extracts the component predicates, invokes &lt;code&gt;summonValidators&lt;/code&gt; to obtain evidence for each, and then combines the resulting validators into a single composite validator. If any component validator is missing, the derivation is blocked.&lt;/p&gt;

&lt;p&gt;A &lt;a href="https://github.com/softwaremill/tapir/blob/master/integrations/iron/src/main/scala/sttp/iron/codec/iron/TapirCodecIron.scala#L30" rel="noopener noreferrer"&gt;usage site&lt;/a&gt; appears in the schema derivation:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;  &lt;span class="n"&gt;given&lt;/span&gt; &lt;span class="n"&gt;ironTypeSchema&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Predicate&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt;
      &lt;span class="n"&gt;vSchema&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Schema&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Value&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="n"&gt;constraint&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;RuntimeConstraint&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Predicate&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
      &lt;span class="n"&gt;validatorTranslation&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;ValidatorForPredicate&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Value&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Predicate&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
  &lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Schema&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Value&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="nc"&gt;Predicate&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="n"&gt;vSchema&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;validatorTranslation&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;validator&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;map&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Value&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="nc"&gt;Predicate&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;v&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;refineOption&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Predicate&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;identity&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;Here, &lt;code&gt;validatorTranslation&lt;/code&gt; may be the composite validator produced by &lt;code&gt;validatorForAnd&lt;/code&gt;. The &lt;code&gt;given&lt;/code&gt; combines the base schema, the runtime constraint, and the validator into a schema for the refined type. This is where the compound evidence is consumed.&lt;/p&gt;

&lt;p&gt;These snippets illustrate how Tapir's Iron integration uses summon‑based recursion and inline givens to assemble evidence from multiple components.&lt;/p&gt;


&lt;h2&gt;
  
  
  A Few Words on Macro-Driven Evidence
&lt;/h2&gt;

&lt;p&gt;Alright, this article is already getting pleasantly dense, and &lt;a href="https://docs.scala-lang.org/scala3/guides/macros/macros.html" rel="noopener noreferrer"&gt;macros&lt;/a&gt; are one of those topics that could easily swallow an entire lecture on their own. So I don't plan to keep you here that much longer. Think of this section as a small and friendly detour, just enough to spark your curiosity, give you a sense of the landscape, and maybe tempt you into exploring macros more deeply on your own.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft7wp5q6egn0z8kn9s9wh.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft7wp5q6egn0z8kn9s9wh.jpg" alt="Attractive Macros" width="800" height="532"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Macros&lt;/em&gt; occupy a special place in Scala’s compile‑time ecosystem. Inline givens and summon‑based derivation operate within the, should I say, normal reduction rules of the type system. They could be used to match on types, recurse over tuples, and assemble evidence step by step. Macros, by contrast, along with &lt;a href="https://docs.scala-lang.org/scala3/guides/macros/quotes.html" rel="noopener noreferrer"&gt;Quotes and Splices&lt;/a&gt;, let a library, or even an application, participate in compilation in a more open‑ended way. They can inspect the full &lt;a href="https://docs.scala-lang.org/scala3/guides/macros/reflection.html#type-and-typerepr" rel="noopener noreferrer"&gt;structure of a type&lt;/a&gt;, generate code, and construct evidence programmatically. In the context of evidence, as you would expect, macros can play the role of the blocker but they could also take on a refinement‑like role. They can analyze a type or even a value at compile time and produce evidence that reflects a more precise understanding of it.&lt;/p&gt;

&lt;p&gt;This makes macros particularly attractive when the shape of the evidence depends on information that is awkward to express through match types alone, or when the derivation logic needs to be more flexible than what inline pattern matching comfortably allows. Many libraries use them sparingly, precisely because they offer so much freedom. They can synthesize complex structures, tailor error messages to the exact shape of a type, and encode domain rules that go beyond what the other techniques in this chapter can &lt;strong&gt;conveniently&lt;/strong&gt; capture.&lt;/p&gt;

&lt;p&gt;And here’s the sweet part. From a developer’s perspective (the one who uses these macros, not the one that implements them), macro‑driven derivation often feels indistinguishable from canonical typeclass evidence.&lt;/p&gt;

&lt;p&gt;This brief mention is not meant to teach macros, only to gesture toward them. If inline matching and summon‑driven derivation now feel familiar, macros are the natural next frontier. &lt;/p&gt;

&lt;p&gt;Trust me, they will reward your deeper study!&lt;/p&gt;

&lt;p&gt;And they open the door to some of the most expressive patterns in Scala’s compile‑time world.&lt;/p&gt;

&lt;p&gt;Inline and summon‑based derivation already allow for sophisticated composition (like structure inspection, branching, recursion, and assembly of complex proof objects), but macros extend this further. A macro can inspect the full structure of a type, run arbitrary compile‑time logic, generate new types or instances, and decide whether to succeed or fail with custom error messages. In effect, a macro acts as a programmable compile‑time proof engine.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxztg8ugyawvmb8chw77d.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxztg8ugyawvmb8chw77d.gif" alt="Longtime Macros Users" width="480" height="270"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Ok, enough rhetoric, let's look at a practical example. 🚀&lt;/p&gt;

&lt;p&gt;A perfect showcase for this is &lt;a href="https://github.com/zio/zio-schema" rel="noopener noreferrer"&gt;ZIO Schema&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;So, to reiterate, the experience of Scala evidence (meaning the way it feels to the user dev) can also be expressed through other features different from typeclasses. Macros, with quotes and splices, being the most powerful of these!&lt;/p&gt;

&lt;p&gt;In order to ilustrate that through a real-world usage, lets take a look to a portion of the &lt;a href="https://github.com/zio/zio-schema/blob/main/zio-schema-derivation/shared/src/main/scala-3/zio/schema/DeriveSchema.scala" rel="noopener noreferrer"&gt;DeriveSchema.scala&lt;/a&gt; file of ZIO Schema.&lt;/p&gt;

&lt;p&gt;From the outside, the API is very simple:&lt;br&gt;
&lt;/p&gt;
&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight scala"&gt;&lt;code&gt;&lt;span class="n"&gt;extension&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Schema&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="kd"&gt;type&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;transparent&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;derived&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;DeriveSchema&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;gen&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;A&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="k"&gt;object&lt;/span&gt; &lt;span class="nc"&gt;DeriveSchema&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;

  &lt;span class="n"&gt;transparent&lt;/span&gt; &lt;span class="n"&gt;inline&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;gen&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Schema&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; $&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;deriveSchema&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

  &lt;span class="k"&gt;private&lt;/span&gt; &lt;span class="kd"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;deriveSchema&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Type&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;using&lt;/span&gt; &lt;span class="nc"&gt;Quotes&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Expr&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nc"&gt;Schema&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt;
    &lt;span class="nc"&gt;DeriveSchema&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;deriveSchema&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;top&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;


&lt;p&gt;In here you can see the macro entry point, the &lt;a href="https://github.com/zio/zio-schema/blob/main/zio-schema-derivation/shared/src/main/scala-3/zio/schema/DeriveSchema.scala#L15" rel="noopener noreferrer"&gt;&lt;code&gt;gen[T]&lt;/code&gt;&lt;/a&gt; method. It delegates the work to the macro implementation, &lt;a href="https://github.com/zio/zio-schema/blob/main/zio-schema-derivation/shared/src/main/scala-3/zio/schema/DeriveSchema.scala#L17" rel="noopener noreferrer"&gt;&lt;code&gt;deriveSchema[T: Type]&lt;/code&gt;&lt;/a&gt;, which in turn invokes the &lt;a href="https://github.com/zio/zio-schema/blob/main/zio-schema-derivation/shared/src/main/scala-3/zio/schema/DeriveSchema.scala#L46" rel="noopener noreferrer"&gt;&lt;code&gt;deriveSchema[T: Type]&lt;/code&gt;&lt;/a&gt; method defined on the &lt;a href="https://github.com/zio/zio-schema/blob/main/zio-schema-derivation/shared/src/main/scala-3/zio/schema/DeriveSchema.scala#L21" rel="noopener noreferrer"&gt;&lt;code&gt;DeriveSchema&lt;/code&gt;&lt;/a&gt; instance. That final method is the one that actually performs the derivation logic, as you’ll see shortly.&lt;/p&gt;

&lt;p&gt;Anyways, a user dev could then write &lt;code&gt;val userSchema: Schema[User] = Schema.derived[User]&lt;/code&gt; and expects one of two outcomes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;p&gt;a &lt;code&gt;Schema[User]&lt;/code&gt; is produced, or&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;compilation fails with a clear message explaining why &lt;code&gt;User&lt;/code&gt; cannot be derived.&lt;/p&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That is exactly the same interaction pattern as &lt;code&gt;val showUser: Show[User] = summon[Show[User]]&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;The internal mechanics are different, but the &lt;em&gt;contract&lt;/em&gt; with the developer is the same.&lt;/p&gt;

&lt;p&gt;Inside &lt;code&gt;DeriveSchema&lt;/code&gt;, the macro performs a kind of compile‑time refinement over the type:&lt;/p&gt;


&lt;div class="ltag_gist-liquid-tag"&gt;
  
&lt;/div&gt;



&lt;p&gt;A few things stand out here:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;The macro first checks for recursion via the &lt;code&gt;Stack&lt;/code&gt; and uses &lt;code&gt;Schema.defer&lt;/code&gt; when it finds a previously seen type.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;It then tries to reuse existing evidence with &lt;code&gt;Expr.summon[Schema[T]]&lt;/code&gt; when not at the top level.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;It pattern‑matches on the shape of the type (&lt;code&gt;List&lt;/code&gt;, &lt;code&gt;Either&lt;/code&gt;, &lt;code&gt;Option&lt;/code&gt;, collections, &lt;code&gt;Chunk&lt;/code&gt;, mirrors for products and sums, sealed traits, &lt;code&gt;OrType&lt;/code&gt; unions).&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;And when none of the supported shapes match, it calls &lt;code&gt;report.errorAndAbort&lt;/code&gt; with a descriptive message.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;From the user’s point of view, this is indistinguishable from typeclass evidence. With typeclasses, &lt;code&gt;summon[Show[A]]&lt;/code&gt; either finds an instance or fails. In a similar way, with ZIO Schema, &lt;code&gt;Schema.derived[A]&lt;/code&gt; either produces a &lt;code&gt;Schema[A]&lt;/code&gt; or fails.&lt;/p&gt;

&lt;p&gt;These blocking modes are analogous. Unsupported types lead to compile‑time errors, and both mechanisms act as compile‑time guards that enforce constraints on which types are acceptable.&lt;/p&gt;

&lt;p&gt;So, as you have seen in the exemple of ZIO Schema, while macros are not &lt;em&gt;evidence&lt;/em&gt; in the canonical Scala sense (they don’t participate in implicit resolution), they fulfil the same practical role. They are invoked in the same &lt;em&gt;just give me the instance&lt;/em&gt; style, they succeed or fail in the same way, and they enforce the same kind of type‑level guarantees. The key difference is internal. Typeclasses look up pre‑defined instances, whereas macros generate the result on the fly. But the thing is, for most user-devs, that distinction is invisible.&lt;/p&gt;




&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;Now that we’ve come to the end, we should ask ourselves: &lt;em&gt;Why does all of this matter, and what is the practical impact on code and teams?&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Well, all of this type‑level machinery for evidence has a real effect on how Scala developers write software!&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;p&gt;APIs become harder to misuse.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Domain invariants become impossible to violate.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Refactoring becomes safer and more predictable.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Complex logic becomes simpler because invalid states are unrepresentable.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Teams gain confidence that the compiler is enforcing the rules they care about.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;And with less boilerplate, the codebase becomes lighter and more expressive.&lt;/p&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But there is a deeper point running through everything we’ve explored.&lt;br&gt;
Scala’s canonical &lt;em&gt;story&lt;/em&gt; for evidence is typeclasses, that’s the familiar shape. Yet the &lt;em&gt;experience&lt;/em&gt; of evidence can be expressed through other Scala 3 features as well: inline definitions, summon‑driven derivation, enrichment of evidence logic through typelevel computations (match types, type lambdas and whatnot) and, at the far end of the spectrum, the freedom king of compile-time logic expression, macros with quotes and splices. These mechanisms differ internally, but from the developer’s perspective they often feel the same. &lt;/p&gt;

&lt;p&gt;You ask the compiler for something, and it either gives you the result, refines it or tells you why it shall not pass.&lt;/p&gt;

&lt;p&gt;This flexibility matters. It means that evidence is not tied to a single construct, but is instead a design space, a way of modeling domain rules, shaping APIs, and guiding developers toward correct usage. Whether the evidence is looked up, computed, or generated, the effect on the domain model is the same, the compiler becomes an active participant in enforcing the logic of the system.&lt;/p&gt;

&lt;p&gt;You see, type‑level evidence isn’t just an academic curiosity for geeks with too much time on their hands. Well, it is all that :) but more importantly, it's also a practical force that shapes codebases, workflows, and engineering culture. And Scala 3 gives us more than one way to express it.&lt;/p&gt;




&lt;p&gt;It was quite an adventure, alright! But, like all good things, it eventually had to come to an end...&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foty82hg37ha11776l7ps.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foty82hg37ha11776l7ps.gif" alt="Sad Jake" width="355" height="264"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Remember tho, every ending is just a new beggining to chase other awesome experiences! 😉&lt;/p&gt;

&lt;p&gt;So, thank you for taking the time to explore how evidence works in Scala, the different ways we can express the same underlying idea, and how these choices shape everyday development practice. And last but not least, thank you for your interest in software engineering!&lt;/p&gt;




&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://docs.scala-lang.org/scala3/guides/" rel="noopener noreferrer"&gt;https://docs.scala-lang.org/scala3/guides/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.scala-lang.org/scala3/reference/" rel="noopener noreferrer"&gt;https://docs.scala-lang.org/scala3/reference/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.scala-lang.org/tour/" rel="noopener noreferrer"&gt;https://docs.scala-lang.org/tour/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://medium.com/@markgrechanik/type-refinements-in-scala-making-your-types-more-sophisticated-than-your-friends-23600b2305d2" rel="noopener noreferrer"&gt;https://medium.com/@markgrechanik/type-refinements-in-scala-making-your-types-more-sophisticated-than-your-friends-23600b2305d2&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/scala/scala3/" rel="noopener noreferrer"&gt;https://github.com/scala/scala3/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus" rel="noopener noreferrer"&gt;https://github.com/BuffBorg-Lectures/rethinking-evidence-passivhaus&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.scala-lang.org/scala3/book/" rel="noopener noreferrer"&gt;https://docs.scala-lang.org/scala3/book/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://horstmann.com/scala/" rel="noopener noreferrer"&gt;https://horstmann.com/scala/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.oreilly.com/library/view/programming-scala-3rd/9781492077886/" rel="noopener noreferrer"&gt;https://www.oreilly.com/library/view/programming-scala-3rd/9781492077886/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.manning.com/books/functional-programming-in-scala-second-edition" rel="noopener noreferrer"&gt;https://www.manning.com/books/functional-programming-in-scala-second-edition&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.artima.com/shop/advanced_programming_in_scala_5ed" rel="noopener noreferrer"&gt;https://www.artima.com/shop/advanced_programming_in_scala_5ed&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.artima.com/shop/programming_in_scala_5ed" rel="noopener noreferrer"&gt;https://www.artima.com/shop/programming_in_scala_5ed&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://nightly.scala-lang.org/docs/internals/gadts.html" rel="noopener noreferrer"&gt;https://nightly.scala-lang.org/docs/internals/gadts.html&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://docs.scala-lang.org/sips/" rel="noopener noreferrer"&gt;https://docs.scala-lang.org/sips/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/typelevel/shapeless-3" rel="noopener noreferrer"&gt;https://github.com/typelevel/shapeless-3&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/softwaremill/tapir" rel="noopener noreferrer"&gt;https://github.com/softwaremill/tapir&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/zio" rel="noopener noreferrer"&gt;https://github.com/zio&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://zionomicon.com/" rel="noopener noreferrer"&gt;https://zionomicon.com/&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>scala</category>
      <category>programming</category>
      <category>typelevel</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Overview of Caching in Web Software Development</title>
      <dc:creator>Ion RA</dc:creator>
      <pubDate>Fri, 17 Mar 2023 14:36:32 +0000</pubDate>
      <link>https://dev.to/ionra/overview-of-caching-in-web-software-development-5fo2</link>
      <guid>https://dev.to/ionra/overview-of-caching-in-web-software-development-5fo2</guid>
      <description>&lt;p&gt;This is a brief overview of caching with emphasis on web software development.&lt;/p&gt;




&lt;h2&gt;
  
  
  What is caching?
&lt;/h2&gt;

&lt;p&gt;Caching is the temporary storage of data in designed locations of a computing environment.&lt;/p&gt;

&lt;p&gt;This is typically done to improve responsiveness and reduce roundabout requests to data stores.&lt;/p&gt;

&lt;p&gt;It can also be used to reduce redundant computations, as might be the case with &lt;a href="https://en.wikipedia.org/wiki/Memoization"&gt;&lt;strong&gt;memoization&lt;/strong&gt;&lt;/a&gt;, in which case the cached data might also be the results of computations that are stored for later retrieval.&lt;/p&gt;

&lt;p&gt;The most common cache on the web is the &lt;a href="https://httpwg.org/specs/rfc9111.html"&gt;&lt;strong&gt;HTTP cache&lt;/strong&gt;&lt;/a&gt;, which represents data from responses that is stored in specific locations to be reused and managed according to HTTP cache specifications.&lt;/p&gt;




&lt;h2&gt;
  
  
  Where is the cache phisically stored?
&lt;/h2&gt;

&lt;p&gt;Caches are physically stored in &lt;a href="https://www.techtarget.com/searchstorage/definition/cache-memory"&gt;&lt;strong&gt;cache memory&lt;/strong&gt;&lt;/a&gt;, which are typically chips (e.g. SRAM) that are integrated or interconnected with various processing units (e.g. CPU, GPU, etc.).&lt;/p&gt;




&lt;h2&gt;
  
  
  When is it appropriate to cache?
&lt;/h2&gt;

&lt;p&gt;Expanding on what was said above, one use case is when the data is consistent during the session.&lt;/p&gt;

&lt;p&gt;Another is in some situations when SQL queries are resource heavy.&lt;/p&gt;

&lt;p&gt;It is worth mentioning that caching could be beneficial when the need to save costs is significant and a priority.&lt;/p&gt;




&lt;h2&gt;
  
  
  What are the most important attributes of HTTP caching?
&lt;/h2&gt;

&lt;p&gt;Broadly speaking, there are two major attributes:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;a href="https://httpwg.org/specs/rfc9111.html#expiration.model"&gt;&lt;strong&gt;Freshness&lt;/strong&gt;&lt;/a&gt; it's a property that sets an expiration frame for the cache and dictates whether or not the cached data is up to date and still relevant for use by the client.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;a href="https://httpwg.org/specs/rfc9111.html#validation.model"&gt;&lt;strong&gt;Validation&lt;/strong&gt;&lt;/a&gt; dictates the techniques for checking with the origin server the expired cached data in order to renew the expiration date or update the cache.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;




&lt;h2&gt;
  
  
  Are there any common practices regarding HTTP caching?
&lt;/h2&gt;

&lt;p&gt;Be aware of &lt;a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching#heuristic_caching"&gt;&lt;strong&gt;heuristic caching&lt;/strong&gt;&lt;/a&gt;, it basically involves always caching data on certain conditions unless otherwise specified. It is best to explicitly set some default cache settings based on your expectations.&lt;/p&gt;

&lt;p&gt;For cache that needs to be updated more often than the expiration period suggests, it's good to consider &lt;a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching#cache_busting"&gt;&lt;strong&gt;cache busting&lt;/strong&gt;&lt;/a&gt;, this means adding a unique symbol to its file name. That way, if a new update is available and ready, it can be downloaded by the browser because it is seen as a new resource, thus bypassing the original cache before the timeout expires.&lt;/p&gt;

&lt;p&gt;Make it a habitt to check and enforce cache validation.&lt;/p&gt;

&lt;p&gt;Usually don't cache resources that can't be cache busted. Do it unless you need more aggressive caching and have mechanisms in place that explicitly purge the cache when it's time for updates.&lt;/p&gt;




&lt;h2&gt;
  
  
  What are some common classifications of web caching?
&lt;/h2&gt;

&lt;p&gt;Altough there are many carachteristics by which caches can be classified, here are two important ones:&lt;/p&gt;

&lt;p&gt;Classification by accessibility:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://httpwg.org/specs/rfc9111.html#rfc.section.4.2.2:~:text=an%20intermediary.%20A-,private%20cache,-%2C%20in%20contrast%2C%20is"&gt;&lt;strong&gt;Private cache&lt;/strong&gt;&lt;/a&gt;, here all cached data is available only to one client, the browser's cache system usually works as a private cache.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://httpwg.org/specs/rfc9111.html#rfc.section.4.2.2:~:text=A-,shared%20cache,-is%20a%20cache"&gt;&lt;strong&gt;Shared cache&lt;/strong&gt;&lt;/a&gt;, here cached data is available and shared by multiple clients. This cache is usually based on a server somewhere on the network.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Classification by network location:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;On the browser&lt;/strong&gt;, here the data is stored locally in the browser according to the set HTTP cache specifications.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;On a proxy server&lt;/strong&gt;, either forward or reverse, here the data is stored on a proxy server inside the network according to the set HTTP cache specifications.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;On the origin server&lt;/strong&gt;, here the data is stored on the server where the web application resides. The origin server cache might involve other caches aswell that differ from the HTTP cache (e.g. database cache and others).&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  How does caching looks like from the backend?
&lt;/h2&gt;

&lt;p&gt;For origin server caching, depending on the technology, there could be different approaches to caching both in terms of API and implementation.&lt;/p&gt;

&lt;p&gt;For example, from the perspective of an ASP.NET application, the following are the most common nuances used for caching:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/memory?view=aspnetcore-7.0"&gt;&lt;strong&gt;In-memory caching&lt;/strong&gt;&lt;/a&gt;. The caching location for this is self-explanatory. It works best for affinity caching, when requests from a client are always routed to the same server.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/distributed?view=aspnetcore-7.0"&gt;&lt;strong&gt;Distributed caching&lt;/strong&gt;&lt;/a&gt;. It is best used in non-affinity cache. This works by distributing cached data between servers.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/response?view=aspnetcore-7.0"&gt;&lt;strong&gt;Response caching&lt;/strong&gt;&lt;/a&gt;. Its components, &lt;a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/response?view=aspnetcore-7.0#responsecache-attribute"&gt;ResponseCacheAttribute&lt;/a&gt; and &lt;a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/middleware?view=aspnetcore-7.0"&gt;Reponse Caching Middleware&lt;/a&gt;, handle cache headers and stores data on the client/proxy server or origin server, according to the HTTP cache specification.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/output?view=aspnetcore-7.0"&gt;&lt;strong&gt;Output caching&lt;/strong&gt;&lt;/a&gt;. This expands on Response Caching Middleware and allows the origin server to store data according to its own specifications.&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;And that, folks, sums it up. If you find these articles valuable and you are interested in more technical discussions or business inquiries, feel free to subscribe or reach out to me!&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
🤖 &lt;a href="https://www.instagram.com/buffborg/"&gt;Instagram&lt;/a&gt;
&lt;/td&gt;
&lt;td&gt;
💼 &lt;a href="https://www.linkedin.com/in/ion-r%C3%A2peanu-andreescu/"&gt;LinkedIn&lt;/a&gt;
&lt;/td&gt;
&lt;td&gt;
💌 &lt;a href="mailto:ionra.contact@gmail.com"&gt;Email&lt;/a&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Hopefully this has given you a better sense of understanding, or at least refreshed your knowledge of caching and its applications on the web. For further research on this topic, you can start with these:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://httpwg.org/specs/rfc9111.html"&gt;https://httpwg.org/specs/rfc9111.html&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.rfc-editor.org/rfc/rfc9112.html"&gt;https://www.rfc-editor.org/rfc/rfc9112.html&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.rfc-editor.org/rfc/rfc9110.html"&gt;https://www.rfc-editor.org/rfc/rfc9110.html&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching"&gt;https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.digitalocean.com/community/tutorials/web-caching-basics-terminology-http-headers-and-caching-strategies"&gt;https://www.digitalocean.com/community/tutorials/web-caching-basics-terminology-http-headers-and-caching-strategies&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.mnot.net/cache_docs/#IMP-SERVER"&gt;https://www.mnot.net/cache_docs/#IMP-SERVER&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.c-sharpcorner.com/UploadFile/225740/introduction-of-caching/"&gt;https://www.c-sharpcorner.com/UploadFile/225740/introduction-of-caching/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://learn.microsoft.com/en-us/aspnet/core/performance/caching/overview?view=aspnetcore-7.0"&gt;https://learn.microsoft.com/en-us/aspnet/core/performance/caching/overview?view=aspnetcore-7.0&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>webdev</category>
      <category>http</category>
      <category>caching</category>
      <category>dotnet</category>
    </item>
    <item>
      <title>Concurrency Model in JavaScript Runtime Environments</title>
      <dc:creator>Ion RA</dc:creator>
      <pubDate>Sat, 03 Sep 2022 15:44:21 +0000</pubDate>
      <link>https://dev.to/ionra/concurrency-model-in-javascript-runtime-environments-34dc</link>
      <guid>https://dev.to/ionra/concurrency-model-in-javascript-runtime-environments-34dc</guid>
      <description>&lt;p&gt;For quite some time now, &lt;strong&gt;JavaScript&lt;/strong&gt; (JS) has been the language that brings the Web to life. So it's no surprise that since 2014, of all programming and scripting languages, JavaScript has consistently been the most popular technology among software developers, according to &lt;a href="https://insights.stackoverflow.com/survey" rel="noopener noreferrer"&gt;Stack Overflow surveys&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;As with other programming languages, JavaScript's capabilities are significantly influenced by the runtime environment in which it runs.&lt;/p&gt;

&lt;p&gt;One crucial aspect that depends on runtimes, which is the main topic of this discussion, is the &lt;strong&gt;Concurrency Model&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;In terms of runtimes, &lt;strong&gt;Node.js&lt;/strong&gt; gets the most focus in this discussion, but browsers like &lt;strong&gt;Edge&lt;/strong&gt;, &lt;strong&gt;Firefox&lt;/strong&gt; and others also get decent coverage.&lt;/p&gt;

&lt;p&gt;As for reader's prerequisites general knowledge of programming languages, curiosity and critical thinking are the three most important things to have, as here, besides coding, are also explained and illustrated principles, concepts and designs for achieving concurrency. But those who have a basic knowledge of JS and C/C++ could get a fine-grained analysis of the implementations.&lt;/p&gt;

&lt;p&gt;For all the readers for whom concepts like timers, promises, threads, event loop, asynchronous behavior and others are just an important piece of magic that JS provides, then this post can help you better understand the depths on which different types of concurrency are achieved in JS runtimes. For those who are veterans of these things, you'll enjoy a good old refresher of the concepts . . . or you might just remember the struggles you overcame learning JavaScript 😂 but either way it's still a post worth reading.&lt;/p&gt;

&lt;p&gt;One more thing before we start, doing all this technical "detective" work to understand JS concurrency, depending on the person it might take some time and effort to ponder and understand, so feel free to break it up into several lectures and read it in your own pace. Also don't hesitate to bring imagination and a cheerful spirit while reading this, it will always make things more memorable. I am no comedian, but I'll try to plant some fun here and there along the way, after all . . . why so serious? &lt;/p&gt;

&lt;p&gt;Alright, enough rhetoric, let's get down to business!&lt;/p&gt;

&lt;h2&gt;
  
  
  What is Concurrency? And what is Parallelism?
&lt;/h2&gt;

&lt;blockquote&gt;
&lt;p&gt;Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once. &lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Well, if you are in a hurry you could just resume to the above quote and move further to the next chapter. But if you want to get a little deeper in these concepts keep reading, it rocks 🚀&lt;/p&gt;

&lt;p&gt;First let's clarify a few terminology used here in the context of computer science talk:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;By &lt;strong&gt;execution&lt;/strong&gt; I refer to the process of actualizing instructions scheduled on a central processing unit (CPU)&lt;/li&gt;
&lt;li&gt;A &lt;strong&gt;program&lt;/strong&gt; is a set of instructions and associated data that is kept on computer storage and that can be loaded and executed/run by an operating system.&lt;/li&gt;
&lt;li&gt;A &lt;strong&gt;process&lt;/strong&gt; represents the actual execution of a program containing whatever resources it requires, like CPU, memory and so on.&lt;/li&gt;
&lt;li&gt;By &lt;strong&gt;system&lt;/strong&gt;, in the context of concurrent/parallel system, I refer either to goal-oriented groups of programs, individual programs, or specific areas of a program.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Now, generally speaking, a system that is composed from several parts, is said to be &lt;strong&gt;concurrent&lt;/strong&gt; if: it is able to register progress without needing all its parts to have executed, the order of execution for its constituents could differ and its final result is not influenced by this order. Like, for example, an operating system 🐧 is a pretty common concurrent system. &lt;/p&gt;

&lt;p&gt;A &lt;strong&gt;parallel&lt;/strong&gt; system is just a concurrent system that takes a step forward by having and conditionally enforcing the ability of execution at the same time of multiple of its constituents. Also, most of the times, an operating system would be a good example here, given that it's running on a multi-core machine.&lt;/p&gt;

&lt;p&gt;Ok, now narrowing it down to the program scope, I would add a few more words about the types of program execution:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt; &lt;strong&gt;Synchronous&lt;/strong&gt; execution refers to the execution of a piece of code line by line in a blocking way, that meaning it does not allow the program to deviate from the order of instructions from the piece of code that it is currently running. Think it like a piece of code with a single execution vector/direction that instructions can be ran. This code actually may be even the entire program.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F4h0i06arkarl1ist7ljm.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F4h0i06arkarl1ist7ljm.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Asynchronous&lt;/strong&gt; execution refers to execution of a piece of code that it is not blocking. This usually manifest while invoking subroutines, these are then scheduled to run on the same processing resource after a certain condition is met or they could run on a separate processing resource, in parallel, if the machine allows it. As you might already figured it out, for code to execute this way the program needs to be concurrent.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwqrfr6rri1od5o96p0i3.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fwqrfr6rri1od5o96p0i3.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What is concurrency needed for?
&lt;/h2&gt;

&lt;p&gt;There are many situations in which some systems need concurrency of some sort for, at least, the appearance of simultaneous execution, in order to preserve a minimum line of acceptance between its users. For example, a user wants to be able to navigate through the web page without feeling lag, that being regardless of what different events it triggers, like opening popup windows, loading images, etc.&lt;/p&gt;

&lt;p&gt;These situations, on the other hand, are likely to be way more prone to lag if they were to happen on synchronous execution. In this case the processing power of the machine it's a much more important factor in determining fluidity of the user experience. For example fetching images may not always resolve fast enough, even if it takes a few seconds this time would be enough to reduce user acceptance. &lt;/p&gt;

&lt;p&gt;Also besides the lag sensation, concurrency, usually parallelism, could be used to increase efficiency and effectiveness of heavy processing programs on multi-core clusters of machines. For example training deep learning models 🤖 could take advantage of a distributed machine cluster.&lt;/p&gt;

&lt;h2&gt;
  
  
  Ok, how is concurrency handled in JavaScript?
&lt;/h2&gt;

&lt;p&gt;Popular JS runtime environments (such as Chrome, Edge, Firefox, Safari, Node.js, Deno, etc.) approach concurrency by first implementing the &lt;strong&gt;event loop&lt;/strong&gt; (EL) concept, than complementing it with a threading technique and lastly using &lt;a href="https://en.wikipedia.org/wiki/Inter-process_communication" rel="noopener noreferrer"&gt;inter-process communication&lt;/a&gt; (IPC). That's it 🎉&lt;/p&gt;

&lt;p&gt;&lt;a href="https://i.giphy.com/media/3o7ypD3Ho7jMArHDxe/giphy.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://i.giphy.com/media/3o7ypD3Ho7jMArHDxe/giphy.gif" alt="GIF"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;In the following chapters we will focus mainly on the first two concepts.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where does the event loop come from?
&lt;/h2&gt;

&lt;p&gt;Ok, let's explain this a little. The first reminiscences of the event loop in JS runtime environments date way back to 1995, very long ago when dinosaurs were still a thing and the dot-com bubble had yet to happen. But anyways, it appeared in the private browser Netscape Navigator. About this you can find &lt;a href="https://www.youtube.com/watch?v=Fv9qT9joc0M&amp;amp;t=1841s" rel="noopener noreferrer"&gt;a discussion by Douglas Crockford on the emergence of the event loop&lt;/a&gt; concept in the browser.&lt;/p&gt;

&lt;p&gt;It is important to keep in mind that event loops adhere to a &lt;strong&gt;cooperative&lt;/strong&gt; mode of multitasking, meaning that one piece of code can hand over the baton to another piece of code only intentionally, there is no mediator such as an operating system scheduling agent to manage access to processing resources for each piece of code.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is the general pattern for the Event Loop?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fm6x8bc4iq62fo6fuccsq.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fm6x8bc4iq62fo6fuccsq.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The event loop is a design pattern that is responsible for delegating messages/events from multiple data structures that can be of different types from each other, in a work environment where they can be consumed.&lt;/p&gt;

&lt;p&gt;The EL can be conditioned in order to harden priorities for: starting the loop, pausing the loop, choosing messages or stopping the loop. Until it encounters stop signals or is not forcibly stopped, the event loop in principle will loop forever.&lt;/p&gt;

&lt;h2&gt;
  
  
  How is the event loop implemented in browsers?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fm5d3yybmq9dh3gegxsq8.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fm5d3yybmq9dh3gegxsq8.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Well there is something called The HTML Standard 📄 this dictates the basic specifications that should be followed in the development of browsers. &lt;a href="https://html.spec.whatwg.org/multipage/webappapis.html#event-loop-processing-model" rel="noopener noreferrer"&gt;The execution specifications for the event loop&lt;/a&gt; are also mentioned there, these specifications differ depending on the &lt;a href="https://html.spec.whatwg.org/multipage/webappapis.html#event-loops" rel="noopener noreferrer"&gt;type of event loop&lt;/a&gt;: window event loop (that is the main event loop), worker event loop, worklet event loop. But it is also worth mentioning that not all browsers respect these specifications the same.&lt;/p&gt;

&lt;p&gt;The EL runs on the same thread as the messages it manages. Depending on the browser, the event loop implementation can be done in a separate library, for example browsers like Chrome and Edge that are based on Google's &lt;strong&gt;Chromium&lt;/strong&gt; project use the &lt;a href="https://github.com/libevent/libevent/blob/21e2862689edc59b6265998c4a1a2729552ab0b1/event.c#L1945" rel="noopener noreferrer"&gt;event loop implementation of the libevent library&lt;/a&gt;, on the other hand Firefox seems to use an in-house implementation, that is quite elusive to find but some point of reference it would be found in the &lt;a href="https://searchfox.org/mozilla-central/rev/d34f9713ae128a3138c2b70d8041a535f1049d19/xpcom/threads/SpinEventLoopUntil.h#156" rel="noopener noreferrer"&gt;searchfox repo&lt;/a&gt;. Broadly speaking, event loop implementations are a conditional while loop.&lt;/p&gt;

&lt;h3&gt;
  
  
  Types of operations
&lt;/h3&gt;

&lt;p&gt;When it comes EL operations, there are two main types of them in browsers:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Task&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Microtask&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Besides these two, you could also add the &lt;code&gt;requestAnimationFrame&lt;/code&gt; (rAF) operation for the Window EL, this operation represents the code that is executed before rendering the next frame on the screen. For this reason, it is recommended that in rAF, the code should be related to the visual effects to be rendered. You can watch nice visuals of it and the event loop in &lt;a href="https://youtu.be/cCOL7MC4Pl0?t=748" rel="noopener noreferrer"&gt;Jake Archibald talk at JSConf&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;There are no subtypes of tasks and microtasks. The prioritization for both types in there respective categories is done depending on the moment in which the operation was invoked.&lt;/p&gt;

&lt;h3&gt;
  
  
  The order of operations
&lt;/h3&gt;

&lt;p&gt;As discussed above, broadly speaking, browser operations can be divided into tasks and microtasks.&lt;/p&gt;

&lt;p&gt;The order of operations being:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;A Task&lt;/li&gt;
&lt;li&gt;All Microtasks (including those newly added by the currently running Microtasks, this may clog the EL)&lt;/li&gt;
&lt;li&gt;Pre-rendering (All Animation Callbacks from rAFs, except those added by the rAFs themself)&lt;/li&gt;
&lt;li&gt;Rendering (recognition of the CSS, then the layout by the browser followed by the actual printing of the page).&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The Pre-rendering and rendering parts could actually be skipped if the browsers decides so, often from optimization issues. Also in the case of Worker and Worklet, this operations do not refer to directly accessing the &lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Introduction" rel="noopener noreferrer"&gt;Document Object Model&lt;/a&gt; (DOM) and its related objects, this not even being allowed, but rather to a virtual canvas specific to each Worker or Worklet.&lt;/p&gt;

&lt;p&gt;Depending on the browser and version, the order of operations may differ more or less from the HTML Standard. But, in general, browsers based on Chromium respect this standard more.&lt;/p&gt;

&lt;h3&gt;
  
  
  Examples of event loop operations in browser
&lt;/h3&gt;

&lt;p&gt;The simple script below should have similar results regardless of which type of EL it runs on:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;workTime&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;mls&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;startDate&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;performance&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;now&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="nx"&gt;currentDate&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;null&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

    &lt;span class="k"&gt;do&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nx"&gt;currentDate&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;performance&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;now&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;while &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;currentDate&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="nx"&gt;startDate&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="nx"&gt;mls&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;runMicrotask&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Start Microtask&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="nf"&gt;workTime&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1000&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;index&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Microtask&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Microtask completed&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;runTask&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Start Task&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="nf"&gt;workTime&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1000&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;index&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Task&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Task completed&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;runAnimationCallback&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;index&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Animation callback&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Animation callback completed&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
    &lt;span class="nf"&gt;requestAnimationFrame&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;runAnimationCallback&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[];&lt;/span&gt;
&lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="nx"&gt;index&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;index&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Start main script&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Start script task&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;

&lt;span class="nf"&gt;setTimeout&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;runTask&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="nf"&gt;queueMicrotask&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;runMicrotask&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="nf"&gt;workTime&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;1000&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;

&lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;index&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;End main script&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Script task completed&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;

&lt;span class="nf"&gt;requestAnimationFrame&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;runAnimationCallback&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A few observations in here:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Be careful how you try to deduce the order of operations. For example, if you rely on &lt;code&gt;console.log&lt;/code&gt;, you should know that it does not have a standardized implementation and may produce inconsistent results depending on the browser and version.&lt;/li&gt;
&lt;li&gt;Below, the order of operations will be judged using array representation, a web API agnostic method. Each operation has its own string or several characteristic strings that it pushes into an array. Depending on the order of these strings in the array, the order of operations is established. Console.log is still used to exemplify possible misleading due to its non-standardized implementation or potential bugs in the browser.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Firefox results:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fuqhvo674g9el0dex8boa.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fuqhvo674g9el0dex8boa.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Edge results:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F2caouu7haui9zd1e88n9.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F2caouu7haui9zd1e88n9.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;As I said, the order of execution differs depending on the browser and version. In the above example, Firefox and Edge seem to respect the standard order of execution, in the case of Firefox it seems it is possible to execute several Animation callbacks until it lets go of the next Task and in the case of Edge it seems that rendering operations do not so easily represent a priority over general tasks. Of course you can play with this example, increase the work time for example and see what happens. For sure you could obtain some different scenarios if changes are meaningful enough, but in general both browsers hold up to the standards. Also keep an eye out for &lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#reasons_for_delays_longer_than_specified" rel="noopener noreferrer"&gt;timeouts minimum waiting time and throttling&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Ok, now notice how trying to identify the order of the EL operations after logging with the console API would have been skewed for Firefox. This indicating a run of the animation callback before the script that initiates rAF has been run in the first place. This can be caused by bugs or different implementations of the &lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/Console_API" rel="noopener noreferrer"&gt;console web API&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;It is also important to point out that rAF, an operation related to rendering, is also available in the worker's dedicated global purpose, even if it does not have direct access to the DOM elements in the window 🤔 Now, this may differ depending on the browser and their version, but it is generally possible because a web worker has access to the computation logic for rendering purposes and not to the rendered document and the actual rendering process. Other rendering functionality of web workers is the offscreen rendering API, &lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas" rel="noopener noreferrer"&gt;OffscreenCanvas&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  How is the event loop implemented in Node.js?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Ffkb4k07mwnabbzmgf966.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Ffkb4k07mwnabbzmgf966.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Aaahh yes, &lt;strong&gt;libuv&lt;/strong&gt;, the Unicorn Velociraptor, or T-Rex, or uhh . . . whatever. This library is responsible for the implementation of EL in Node.js. &lt;a href="https://github.com/libuv/libuv/blob/69ebb2d720ac476248460e1fb3f0f3d10af483dc/src/win/core.c#L592" rel="noopener noreferrer"&gt;The implementation for Windows systems&lt;/a&gt; can be found on GitHub as well as &lt;a href="https://github.com/libuv/libuv/blob/69ebb2d720ac476248460e1fb3f0f3d10af483dc/src/unix/core.c#L372" rel="noopener noreferrer"&gt;the implementation for UNIX systems&lt;/a&gt;. &lt;/p&gt;

&lt;p&gt;In there you can see that these implementations are just a while loop conditioned by certain criteria. In terms of execution, it can be observed that it executes in order a list of different groupings of messages. A difference from the browser is that In this JS runtime, there is only one type of event loop, which means that if worker threads or child processes are spawned, they will all have an event loop that follows the same specifications.&lt;/p&gt;

&lt;p&gt;At the time of writing this article Node.js 16.14.2 is the LTS version and Node.js 18.6.0 is the latest Stable version. From &lt;a href="https://github.com/nodejs/node/commit/af6f1d512db1840bd837e1e8001a22bb7a450a41" rel="noopener noreferrer"&gt;the LTS version onwards, in this commit you can see the last used version of libuv&lt;/a&gt;, i.e. libuv 1.43.0&lt;/p&gt;

&lt;p&gt;Below you can have a look on libuv's basic composition diagram.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fu3tglijbsyyyv9y6rw66.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fu3tglijbsyyyv9y6rw66.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  Types of operations and their order
&lt;/h3&gt;

&lt;p&gt;&lt;em&gt;Alright now, hold on a minute, you reached about the middle of this article, congrats! Now, just a reminder, if you already spent some good time staring at the screen, probably while sitting on a chair or something, then now it would be a good time to take a minute to relax, get up, go for a walk, stare a little bit into the distance, don't forget to blink and drink your water! Alright? Good!&lt;/em&gt; 🙂&lt;/p&gt;

&lt;p&gt;Getting back to our regular scheduled programming. Unlike the browser, in Node.js there are 4 types of main phases/operations in which you can set callback functions and 2 types of secondary phases, in which you can set callback functions. &lt;/p&gt;

&lt;p&gt;Main phases:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Expired Timers&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;IO tasks&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Immediates&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Close Handlers&lt;/strong&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Secondary phases:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;nextTicks&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;Microtasks (&lt;strong&gt;Promises/queueMicrotask&lt;/strong&gt;)&lt;/li&gt;
&lt;/ol&gt;

&lt;blockquote&gt;
&lt;p&gt;The order is simple, first the main script is executed than it starts looping the main phases in the order they are listed above. At each main phase all of the associated callbacks are executed. Where do the secondary phases come into play, you may ask? Well immediately after the main script is executed and after each execution of one callback from a main phase, all the callbacks from each of the two secondary phases are executed in the order they are listed above.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Take notice that to enter the execution phase of IO tasks, EL does not wait until all immediate callbacks of the previous tick are all executed, especially if there are many of them enqueued.&lt;/p&gt;

&lt;p&gt;In UNIX systems, but also in Windows systems, timer callbacks are stored in a &lt;a href="https://github.com/libuv/libuv/blob/f6dfbcec76f423dfac16e6842f0c8dfd3e91bb92/include/uv/unix.h#L245" rel="noopener noreferrer"&gt;min-heap&lt;/a&gt;, called &lt;a href="https://github.com/libuv/libuv/blob/f6dfbcec76f423dfac16e6842f0c8dfd3e91bb92/include/uv/unix.h#L245" rel="noopener noreferrer"&gt;timer_heap&lt;/a&gt; which is a property of the structure that represents the EL. While the &lt;a href="https://github.com/libuv/libuv/blob/v1.43.0/include/uv/unix.h#L224" rel="noopener noreferrer"&gt;pending IO&lt;/a&gt;, &lt;a href="https://github.com/libuv/libuv/blob/v1.43.0/include/uv/unix.h#L225" rel="noopener noreferrer"&gt;IO poll&lt;/a&gt; and &lt;a href="https://github.com/libuv/libuv/blob/v1.43.0/src/unix/loop.c#L53" rel="noopener noreferrer"&gt;immediate&lt;/a&gt; callbacks are memorized in queue data structures. And the way in which &lt;a href="https://github.com/libuv/libuv/blob/v1.43.0/src/unix/core.c#L212" rel="noopener noreferrer"&gt;close handlers&lt;/a&gt; callbacks are stored denotes the fact that they are also stored in a queue-type data structure.&lt;/p&gt;

&lt;p&gt;The code below shows the complete phases (including those that do not allow you to set callback functions) of the UNIX EL (the Windows ones are similar) from libuv 1.43.0. The comments were removed from code for better representation.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight c"&gt;&lt;code&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;uv_run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;uv_loop_t&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;uv_run_mode&lt;/span&gt; &lt;span class="n"&gt;mode&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;timeout&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;ran_pending&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;uv__loop_alive&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__update_time&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;while&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="n"&gt;stop_flag&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__update_time&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__run_timers&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;ran_pending&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;uv__run_pending&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__run_idle&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__run_prepare&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;timeout&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;mode&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;UV_RUN_ONCE&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;ran_pending&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="n"&gt;mode&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;UV_RUN_DEFAULT&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;timeout&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;uv_backend_timeout&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__io_poll&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;timeout&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__metrics_update_idle_time&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__run_check&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__run_closing_handles&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;mode&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;UV_RUN_ONCE&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__update_time&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;uv__run_timers&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;uv__loop_alive&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;mode&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;UV_RUN_ONCE&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="n"&gt;mode&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;UV_RUN_NOWAIT&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;break&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="n"&gt;stop_flag&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="n"&gt;loop&lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="n"&gt;stop_flag&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The 4 main phases are represented by the following functions:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;a href="https://github.com/libuv/libuv/blob/v1.43.0/src/timer.c#L163" rel="noopener noreferrer"&gt;uv__run_timers&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/libuv/libuv/blob/v1.43.0/src/unix/core.c#L806" rel="noopener noreferrer"&gt;uv__run_pending&lt;/a&gt; / &lt;a href="https://github.com/libuv/libuv/blob/v1.43.0/src/unix/epoll.c#L103" rel="noopener noreferrer"&gt;uv__io_poll&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/libuv/libuv/blob/v1.43.0/src/unix/loop-watcher.c#L48" rel="noopener noreferrer"&gt;uv__run_check&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/libuv/libuv/blob/v1.43.0/src/unix/core.c#L312" rel="noopener noreferrer"&gt;uv__run_closing_handles&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Note that the execution order of a Close Handler callback depends on how the close event was issued. That is, it was closed abruptly (such as socket.destroy), then it will be treated regularly by being the last phase that is executed in the event loop, if it was closed in smooth mode (such as server.close), then the close callback will be treated as a &lt;code&gt;nextTick&lt;/code&gt; callback.&lt;/p&gt;

&lt;p&gt;Below is a mention from &lt;a href="https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#close-callbacks" rel="noopener noreferrer"&gt;the official Node.js documentation about close callbacks&lt;/a&gt;:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fcz2sf3nn7vmc64iehgy4.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fcz2sf3nn7vmc64iehgy4.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Related to &lt;a href="https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout" rel="noopener noreferrer"&gt;the differences in the node docs between timers and immediates&lt;/a&gt; the order of execution is not practically deterministic in all possible cases. It appears that determinism appears as soon as we have an IO callback. Since then it is clear that all immediate callbacks will execute first than followed by timer callbacks in the next tick of the loop.&lt;/p&gt;

&lt;p&gt;The execution of callbacks from a queue of a main phase is done, in general, until exhaustion. However, there is also a limit up to which it executes callbacks. After each executed callback of a main phase, EL then runs all the callbacks from the secondary phases until it moves to the next callback from a main phase (&lt;a href="https://github.com/nodejs/node/pull/22842" rel="noopener noreferrer"&gt;this execution relationship between task and microtask has been discussed&lt;/a&gt; to be implemented in nodejs since 2018) .&lt;/p&gt;

&lt;p&gt;Now, things may get a bit more complicated, so strap on to your sits. Even though so far it appeared that the secondary phases belong to the EL, well . . . they actually don't 😲 they are not even once mentioned in libuv, they can be considered add-ons maintaining and extending the general flow of the event loop.&lt;/p&gt;

&lt;p&gt;Wait there is more!&lt;/p&gt;

&lt;p&gt;There needs to be something that links the low level C code of libuv to the high level JS code. Between JS land (that is everything written in JS) and libuv (the C land practically) there is code that makes the binding between the two worlds and that code it resides in the C++ land 🤯 Yes folks you read it right, that is how JS can communicate with C and that is where from JS we can use the microtask and nextTick logic.&lt;/p&gt;

&lt;p&gt;These Node.js bindings are actually quite a broad topic that deserves its own separate discussion. But to keep it short, the C++ ==&amp;gt; JS most significant binding point to highlight how the secondary phases are added on to libuv's EL is represented by the &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/src/api/callback.cc#L166" rel="noopener noreferrer"&gt;InternalMakeCallback&lt;/a&gt; function.&lt;/p&gt;

&lt;p&gt;Basically, this C++ function is where the propagation to the JS land of the execution command for a main phase callback coming from the EL is triggered. And besides that here is also where it's triggered &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/src/api/callback.cc#L219" rel="noopener noreferrer"&gt;the propagation to the JS land of the execution command for all secondary phases callbacks&lt;/a&gt;, but this time coming not from EL, but either from C++ land in case of nextTicks or from the &lt;a href="https://v8.dev/docs" rel="noopener noreferrer"&gt;V8 engine&lt;/a&gt; for promises.&lt;/p&gt;

&lt;p&gt;Finally the code that traverses the these two queues is located in JS Land, in the &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/lib/internal/process/task_queues.js#L68" rel="noopener noreferrer"&gt;processTicksAndRejections&lt;/a&gt; function.&lt;/p&gt;

&lt;p&gt;Libuv is not aware of the presence of any microtask or nextTick queues. Only C++ Land and JS Land are aware of their existence.&lt;/p&gt;

&lt;p&gt;Ok, I know for some of you this might be a little bit hard to keep track of&lt;/p&gt;

&lt;p&gt;&lt;a href="https://i.giphy.com/media/h3Jxu7a7pd72w/giphy.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://i.giphy.com/media/h3Jxu7a7pd72w/giphy.gif" alt="GIF"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;And for good reasons. It actually could be elaborated even further, but I think summarizing it to those things that are most important is enough for the scope of this lecture, after all the binding points, API mappings, their mechanisms of action and whatnot are actually quite numerous.&lt;/p&gt;

&lt;p&gt;Also keep in mind that the current 16.14.2 LTS version gradually received changes for its bindings, so in this regard older versions may differ quite a bit.&lt;/p&gt;

&lt;p&gt;Fortunately for those who are interested to know more, starting from the references presented in here and going towards JS or C, you can actually follow up (or track down 🙃) these bindings by yourself. &lt;/p&gt;

&lt;p&gt;Anyways, it will get easier towards the end, I promise 😉🤞&lt;/p&gt;

&lt;h3&gt;
  
  
  Examples of event loop operations in Node.js
&lt;/h3&gt;

&lt;p&gt;Add the script below in a file, name it whatever, myScript.js if you will, and run it with Node.js. For example &lt;code&gt;node myScript.js&lt;/code&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nx"&gt;fs&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;fs&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nx"&gt;net&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;net&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;workTime&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;mls&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;startDate&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;performance&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;now&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="nx"&gt;currentDate&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;null&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;currentDate&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;performance&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;now&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;while &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;currentDate&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="nx"&gt;startDate&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="nx"&gt;mls&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;runTask&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;taskName&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;timeForRunning&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueNextTickArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;nextTickArray&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueMicrotaskArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;microtaskArray&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;

&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;timeForRunning&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;workTime&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;timeForRunning&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; 
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;index&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;taskName&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;runTimmer&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;runTask&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Timmer&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;500&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;runImmediate&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;runTask&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Immediate&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;500&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;runNextTick&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;index&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Next tick&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;runMicrotask&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;index&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Microtask&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;runCloseHandler&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;runTask&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Close Handler&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;500&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;queueTaskArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;taskArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;queueFucntion&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;taskArray&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;forEach&lt;/span&gt;&lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="nx"&gt;taskCallback&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueFucntion&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;taskCallback&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;queueMicrotaskArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;microtaskArray&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueTaskArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;microtaskArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;queueMicrotask&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;queueNextTickArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;nextTickArray&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueTaskArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;nextTickArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;nextTick&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;queueTimmerArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;timmerArray&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueTaskArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;timmerArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;setTimeout&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;queueImmediateArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;immediateArray&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueTaskArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;immediateArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;setImmediate&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;queueCloseHandlerArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;closeHandlerArray&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueTaskArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;closeHandlerArray&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;closeHandlerCallback&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;socket&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;net&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;createConnection&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;&lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;8080&lt;/span&gt;&lt;span class="p"&gt;});&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;socket&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;on&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;close&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;closeHandlerCallback&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;socket&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;destroy&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;ioCallback&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;err&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;index&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;IO&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;err&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;err&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;loops&lt;/span&gt;&lt;span class="o"&gt;--&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueTimmerArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;timmerArray&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueImmediateArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;immediateArray&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueNextTickArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;nextTickArray&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueMicrotaskArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;microtaskArray&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nf"&gt;queueCloseHandlerArray&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;clsoeHandlerArray&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;fs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;readFile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;someFileOnYourComputer.txt&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;utf8&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;ioCallback&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;eventLoopPhasesArray&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[];&lt;/span&gt;
&lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="nx"&gt;index&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="nx"&gt;loops&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;timmerArray&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Array&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;fill&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;runTimmer&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;immediateArray&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Array&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;fill&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;runImmediate&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;nextTickArray&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Array&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;fill&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;runNextTick&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;microtaskArray&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Array&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;fill&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;runMicrotask&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;clsoeHandlerArray&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;Array&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;fill&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;runCloseHandler&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;

&lt;span class="nx"&gt;fs&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;readFile&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;someFileOnYourComputer.txt&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;utf8&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;ioCallback&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;So this example is pretty simple, here are a few observations:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;As with the example for browsers, we register the order of operations by adding their name to an array. &lt;/li&gt;
&lt;li&gt;You can pass arrays of callbacks to be synchronously scheduled for each phase of EL, except IO, using &lt;code&gt;queue. . .Array&lt;/code&gt; functions.&lt;/li&gt;
&lt;li&gt;The loop starts with an IO callback, that is to avoid the uncertainty of order from the beginning of the program of timers and immediates.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The result should be similar to the one below:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fx12xfyevd5j6ixp58i5j.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fx12xfyevd5j6ixp58i5j.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;You can play with this example and test different scenarios. For example you can enqueue a &lt;code&gt;nextTick&lt;/code&gt; callback at the same level with the first &lt;code&gt;fs.readFile&lt;/code&gt; call and see what happens. &lt;/p&gt;

&lt;h2&gt;
  
  
  What are the general principles of multithreading? Something JS specific?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Ftsklm3vk86khm855qjak.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Ftsklm3vk86khm855qjak.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;As I specified above, JS runtimes complement the concurrent experience of EL with a thread implementation technique. This resulted from the computational necessity of some more demanding tasks in which parallelism through threads proved to be useful. &lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;There are also cases in which parallelism needs to be reached by other means, like for example to improve tolerance to failure. Here it comes IPC. To further expand on this subject you can check &lt;a href="https://www.chromium.org/developers/design-documents/multi-process-architecture/" rel="noopener noreferrer"&gt;Chromium's approach&lt;/a&gt; and also &lt;a href="https://blog.mozilla.org/attack-and-defense/2021/04/27/examining-javascript-inter-process-communication-in-firefox/" rel="noopener noreferrer"&gt;Firefox's approach&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;In browsers JS threads are generally known as web workers, and in Node.js they are called worker threads.&lt;/p&gt;

&lt;p&gt;A few bits of theory here. The concurrent nature of a system can be achieved using two models, &lt;a href="https://en.wikipedia.org/wiki/Preemption_(computing)#PREEMPTIVE" rel="noopener noreferrer"&gt;preemptive multitasking&lt;/a&gt; and &lt;a href="https://en.wikipedia.org/wiki/Cooperative_multitasking" rel="noopener noreferrer"&gt;cooperative multitasking&lt;/a&gt;. The later we talked about already, the former it means quite the opposite of the later, that is pieces of code hand on the baton to each other only under the decision of a common supervisor, like the operating system for example.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;With great power comes great responsibility! And that is why programs in Node.js and browsers, whether with or without threads, are exposed to race conditions. You can check &lt;a href="https://www.nodejsdesignpatterns.com/blog/node-js-race-conditions/" rel="noopener noreferrer"&gt;an article by Luciano Mammino about race conditions in JS&lt;/a&gt; for further details on this topic.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Until I get further into the specific details of JS threads, it is also worth mentioning a few laws about the maximum speed that can be reached in paralyzing the execution of a program. In this context, according to the theory, there are several laws, some more practical than others depending on the situation, but all specify how much the execution time of a program can be minimized by reaching an upper limit of performance  through parallelization that it cannot exceed no matter how many more processors are added into the mix. Often the usage of these laws, more for orientation purpose, happens in the architecture point of an application.&lt;/p&gt;

&lt;p&gt;Ok, here they are:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;a href="https://en.wikipedia.org/wiki/Amdahl's_law" rel="noopener noreferrer"&gt;Amdahl's law&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://en.wikipedia.org/wiki/Gustafson%27s_law" rel="noopener noreferrer"&gt;Gustafson's law&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Details about these two are outside the scope of this discussion, but if you want to purse the theory about them you can follow the leads above. &lt;/p&gt;

&lt;p&gt;And one more thing, the multithreading technique, in general, is also supported by the stagnation of the processing speed of only one CPU core. This is something that was observed in &lt;a href="https://en.wikipedia.org/wiki/Moore%27s_law" rel="noopener noreferrer"&gt;Moore's law&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does JavaScript work with threads in browser?
&lt;/h2&gt;

&lt;p&gt;In browser, threads are known as &lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API" rel="noopener noreferrer"&gt;web workers&lt;/a&gt; and are made available through an internal API.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://html.spec.whatwg.org/multipage/workers.html" rel="noopener noreferrer"&gt;These web workers have general specifications mentioned in the HTML standard&lt;/a&gt; according to which implementations in different browsers are oriented, but depending of browser and version these might slightly differ. Hmm I wonder where have I heard that before 🤔&lt;/p&gt;

&lt;p&gt;In terms of relationship between threads, usually those threads that spawn other threads are called &lt;strong&gt;parent threads&lt;/strong&gt;, and the other ones &lt;strong&gt;child threads&lt;/strong&gt;. Those who are children of same parent are called &lt;strong&gt;sibling threads&lt;/strong&gt;. Pretty straight forward, huh?&lt;/p&gt;

&lt;p&gt;Communication between child threads and the parent thread is done with the help of the &lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage" rel="noopener noreferrer"&gt;postMessage&lt;/a&gt; function or &lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/Worker/message_event" rel="noopener noreferrer"&gt;message event&lt;/a&gt; function, which are the access points in an internal &lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel" rel="noopener noreferrer"&gt;MessageChannel&lt;/a&gt; created for communication between parent and child thread.&lt;/p&gt;

&lt;p&gt;You can also create your own MessageChannel instances for communication between threads of any kind and &lt;a href="https://html.spec.whatwg.org/multipage/browsers.html#browsing-context" rel="noopener noreferrer"&gt;browsing contexts&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;There are 3 types of workers in browser:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope" rel="noopener noreferrer"&gt;Dedicated workers&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker" rel="noopener noreferrer"&gt;Shared workers&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API" rel="noopener noreferrer"&gt;Service workers&lt;/a&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;In terms of composition, according to specifications, when a web worker is created it should receive &lt;a href="https://html.spec.whatwg.org/multipage/workers.html#worker-event-loop" rel="noopener noreferrer"&gt;its own instance of EL&lt;/a&gt; and memory resources separated from the other threads.&lt;/p&gt;

&lt;p&gt;On efficiency side of things, most browsers implement something called thread pool, basically a group of already created threads that can be used for CPU intensive operations. The number of threads in the pool does not have to be very high, as discussed earlier the best effort done in parallel is limited by the hardware. You can check out &lt;a href="https://source.chromium.org/chromium/chromium/src/+/main:base/task/thread_pool.h;l=68" rel="noopener noreferrer"&gt;the thread pool implementation for Chromium browsers&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/mdn/dom-examples/tree/master/web-workers" rel="noopener noreferrer"&gt;Some examples of Web Workers&lt;/a&gt; can be found from MDN.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does JavaScript work with threads in Node.js?
&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;Alright, I guess this is the last lesson. Not much more left to go and you'll witness the true powers of concurrent programming. So, what are you waiting for? Let's do it.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://i.giphy.com/media/3o84sw9CmwYpAnRRni/giphy.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://i.giphy.com/media/3o84sw9CmwYpAnRRni/giphy.gif" alt="GIF"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;In Node.js threads can be used with the &lt;strong&gt;worker_threads.js&lt;/strong&gt; module. This have become a stable functionality starting with Node.js 12.15&lt;/p&gt;

&lt;p&gt;Regarding composition, each worker thread has its own instance of V8 engine with queues for microtasks and their own &lt;strong&gt;memory heap&lt;/strong&gt;, plus their own instance of libuv event loop.&lt;/p&gt;

&lt;p&gt;Just like browsers, in order to make working with threads more efficient Node.js also supports the thread pool concept.&lt;/p&gt;

&lt;p&gt;In Node.js communication between threads can be done in an asynchronous 2-way-communication style by using &lt;code&gt;MessageChannel&lt;/code&gt; objects.&lt;/p&gt;

&lt;p&gt;A few more words about data passing. There are 3 ways to pass data between threads:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Cloning data&lt;/li&gt;
&lt;li&gt;Transfer (could be done with &lt;code&gt;ArrayBuffer&lt;/code&gt;, &lt;code&gt;MessagePort&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;Shared data (with &lt;code&gt;SharedArrayBuffer&lt;/code&gt;)&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;A quick tip here, the &lt;a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics" rel="noopener noreferrer"&gt;Atomics Module&lt;/a&gt; can be used to synchronize shared data. It is already integrated since Node.js version 16 LTS onwards ⬆️ and in modern browsers as well.&lt;/p&gt;

&lt;p&gt;In terms of bindings, the creation and initiation of threads starts from the JS land with the &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/lib/internal/worker.js" rel="noopener noreferrer"&gt;worker.js&lt;/a&gt; file. The Worker class from JS Land is linked in the C++ land to the file &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/src/node_worker.cc" rel="noopener noreferrer"&gt;node_worker.cc&lt;/a&gt;, by &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/lib/internal/worker.js#L185" rel="noopener noreferrer"&gt;calling a constructor called WorkerImpl&lt;/a&gt;, which &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/lib/internal/worker.js#L65" rel="noopener noreferrer"&gt;is a bounding point to C++ land&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Going back to worker composition, in node_worker.cc you can actually see how new resources are allocated for the thread, such as the parent &lt;code&gt;MessagePort&lt;/code&gt;, its own libuv EL, its own Heap, an isolated V8 engine, etc.&lt;/p&gt;

&lt;p&gt;Access from user land (that is whatever JS files written by the users) is provided by &lt;code&gt;worker_threads&lt;/code&gt; module exports, we know that. But regarding communication concepts besides &lt;code&gt;MessagePort&lt;/code&gt; and other similar constructs, &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/lib/internal/worker/io.js#L28" rel="noopener noreferrer"&gt;MessageChannel is also available by being imported in worker/io.js file&lt;/a&gt;. This is actually a bounding point to C++ land by being associated to the &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/src/node_messaging.cc#L1411" rel="noopener noreferrer"&gt;MessageChannel function&lt;/a&gt; from the &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/src/node_messaging.cc" rel="noopener noreferrer"&gt;node_messaging.cc&lt;/a&gt; file.&lt;/p&gt;

&lt;p&gt;Now, thread initiation, that includes resource allocation, is started at the moment of creation with &lt;code&gt;new Worker(. . .)&lt;/code&gt;. This Worker constructor implementation resides in worker.js file, and when &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/lib/internal/worker.js#L259" rel="noopener noreferrer"&gt;this[kHandle].startThread() it's called inside it&lt;/a&gt; it will activate a binding point to C++ land by calling to its association &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/src/node_worker.cc#L579" rel="noopener noreferrer"&gt; the StartThread function&lt;/a&gt; from node_worker.cc which ends up doing all the dirty work for us 😎&lt;/p&gt;

&lt;p&gt;Finally, the actual execution of the script by the newly created thread starts in the &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/lib/internal/main/worker_thread.js" rel="noopener noreferrer"&gt;worker_threrad.js&lt;/a&gt; file. More precisely &lt;a href="https://github.com/nodejs/node/blob/v16.14.2/lib/internal/main/worker_thread.js#L104" rel="noopener noreferrer"&gt;when the script it's loaded in there&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://i.giphy.com/media/Quh1CAKOTRCl9VVU3f/giphy.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://i.giphy.com/media/Quh1CAKOTRCl9VVU3f/giphy.gif" alt="GIF"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  Examples of operations with worker threads
&lt;/h3&gt;

&lt;p&gt;Below is the script file to be ran:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nx"&gt;Worker&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;MessageChannel&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;worker_threads&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;worker1&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;Worker&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;./workerScript.js&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;worker2&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;Worker&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;./workerScript.js&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="kd"&gt;let&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nx"&gt;port1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;port2&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;MessageChannel&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;

&lt;span class="nx"&gt;worker1&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;on&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;message&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;message&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;`MAIN THREAD: Message from child worker [id: &lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;worker1&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;threadId&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;] is "&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;message&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"`&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;

&lt;span class="nx"&gt;worker2&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;on&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;message&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;message&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;`MAIN THREAD: Message from child worker [id: &lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;worker2&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;threadId&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;] is "&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;message&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"`&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;

&lt;span class="nx"&gt;worker1&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;postMessage&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;&lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;port1&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;worker1&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;threadId&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;siblingId&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;worker2&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;threadId&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;port1&lt;/span&gt;&lt;span class="p"&gt;]);&lt;/span&gt;
&lt;span class="nx"&gt;worker2&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;postMessage&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;&lt;span class="na"&gt;port&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;port2&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;worker2&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;threadId&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;siblingId&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;worker1&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;threadId&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="nx"&gt;port2&lt;/span&gt;&lt;span class="p"&gt;]);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;And below is the workerScript.js file:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nx"&gt;parentPort&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;worker_threads&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;

&lt;span class="nx"&gt;parentPort&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;on&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;message&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;message&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nx"&gt;port&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;siblingId&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;message&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;parentPort&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;postMessage&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Got the channel details&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;

&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;port&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;on&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;message&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;message&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;`WORKER THREAD[ID: &lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;id&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;]: Message from sibling worker [id: &lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;siblingId&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;] is "&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;message&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"`&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="err"&gt;&amp;nbsp;&lt;/span&gt; &lt;span class="nx"&gt;port&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;postMessage&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Hakuna Matata!&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A few words about what this code is supposed to do:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The parent thread creates two child threads that are supposed to talk between each other.&lt;/li&gt;
&lt;li&gt;To do so it also creates a &lt;code&gt;MessageChannel&lt;/code&gt; whose ports it transfers, one each, to the child threads.&lt;/li&gt;
&lt;li&gt;Then the siblings can talk with each other.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The result should be similar to the one below, the order does not have to be the same.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F6u8hcy16s4r8pnc2fuam.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F6u8hcy16s4r8pnc2fuam.png" alt="Image"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Feel free to play around with this example. Maybe try using one file for all threads, see how you can do that. &lt;/p&gt;

&lt;p&gt;&lt;em&gt;Hint: you may need to use the &lt;code&gt;isMainThread&lt;/code&gt; property.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusion
&lt;/h2&gt;

&lt;p&gt;And that pretty much sums it up folks. Of course, there are more things to talk about on this topic, but that can be for another time.&lt;/p&gt;

&lt;p&gt;Most importantly, you now not only have a good understanding of the big picture of concurrency in JS runtimes and how it all comes together, but you also have good leads and know where to look 🔎&lt;/p&gt;

&lt;p&gt;And last, but certainly not least, thank you for your interest in software engineering!&lt;/p&gt;

&lt;h2&gt;
  
  
  References
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://nodejs.org/docs/latest-v16.x/api/index.html" rel="noopener noreferrer"&gt;https://nodejs.org/docs/latest-v16.x/api/index.html&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/nodejs/node/tree/v16.14.2" rel="noopener noreferrer"&gt;https://github.com/nodejs/node/tree/v16.14.2&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="http://docs.libuv.org/en/v1.x" rel="noopener noreferrer"&gt;http://docs.libuv.org/en/v1.x&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/libuv/libuv/tree/v1.43.0" rel="noopener noreferrer"&gt;https://github.com/libuv/libuv/tree/v1.43.0&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://nikhilm.github.io/uvbook/index.html" rel="noopener noreferrer"&gt;https://nikhilm.github.io/uvbook/index.html&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://libevent.org/" rel="noopener noreferrer"&gt;https://libevent.org/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://searchfox.org/mozilla-central/source/" rel="noopener noreferrer"&gt;https://searchfox.org/mozilla-central/source/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/chromium/chromium" rel="noopener noreferrer"&gt;https://github.com/chromium/chromium&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/libevent/libevent" rel="noopener noreferrer"&gt;https://github.com/libevent/libevent&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.nodejsdesignpatterns.com/" rel="noopener noreferrer"&gt;https://www.nodejsdesignpatterns.com/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://firefox-source-docs.mozilla.org/" rel="noopener noreferrer"&gt;https://firefox-source-docs.mozilla.org/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.chromium.org/developers/" rel="noopener noreferrer"&gt;https://www.chromium.org/developers/&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://v8.dev/docs" rel="noopener noreferrer"&gt;https://v8.dev/docs&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://spidermonkey.dev/docs/" rel="noopener noreferrer"&gt;https://spidermonkey.dev/docs/&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>javascript</category>
      <category>node</category>
      <category>programming</category>
      <category>concurrency</category>
    </item>
  </channel>
</rss>
