Patch up links to new posts

Author: dmiller

_posts/2025-08-31-classic-clojure-compiler-contemplation.md

@@ -14,12 +14,12 @@ The other posts in the series are:
 - [C4: Symbolic of what?]({{site.baseurl}}{% post_url 2025-09-02-symbolic-of-what %}) - A little digression on what symbols represent
 - [C4: ISeq clarity]({{site.baseurl}}{% post_url 2025-09-03-iseq-clarity %}) - How to analyze an `ISeq`
 - [C4: Functional anatomy]({{site.baseurl}}{% post_url 2025-09-04-functional-anatomy %}) - How functions are implemented in Clojure
-- __C4: fn*: talkin' 'bout my generation__ - Code-gen for functions
-- __C4: Tag! You're int!__ - Type analysis by the compiler
-- __C4: Primitive urges__ -- How primitive types are handled 
-- __C4: Inline skating__ - How inlining is used to optimize performance
-- __C4: Key in-site__  Keyword callsites
-- __C4: Is there a protocol for that?__ -- Protocol implementation
+- [C4: fn*: talkin' 'bout my generation]({{site.baseurl}}{% post_url 2025-10-15-fn-star-talkin-bout-my-generation %}) - Code-gen for functions
+- [C4: Tag! You're int!]({{site.baseurl}}{% post_url 2025-10-16-tag-youre-int %}) - Type analysis by the compiler
+- [C4: Primitive urges]({{site.baseurl}}{% post_url 2025-10-17-primitive-urges %}) - How primitive types are handled
+- [C4: Inline skating]({{site.baseurl}}{% post_url 2025-10-18-inline-skating %}) - How inlining is used to optimize performance
+- [C4: Key in-site]({{site.baseurl}}{% post_url 2025-10-19-key-in-site %}) - Keyword callsites
+- [C4: Is there a protocol for that?]({{site.baseurl}}{% post_url 2025-10-20-is-there-a-protocol-for-that %}) - Protocol implementation
 - __C4: A time for reflection__ -- Reflection and dynamic callsites
 - __C4: Out of control__ -- Some points about flow of control and data in the compiler
 - __C4: Some assembly required__ -- Assembly generation for AOT compilation

_posts/2025-10-15-fn-star-talkin-bout-my-generation.md

@@ -55,7 +55,7 @@ The `ObjExpr` class maintains the following collections:
 - `ProtocolCallsites`: places where protocol methods are called.  
 
 
-`Constants` contributes static fields to the function class. `Closes` defines the values needed for the constructor of the function class. `KeywordCallsites` and `ProtocolCallsites` also contribute static fields.  We'll discuss keyword callsites in [C4: Key in-site][TBD].  We'll discuss protocol callsites in [C4: Is there a protocol for that?][TBD].
+`Constants` contributes static fields to the function class. `Closes` defines the values needed for the constructor of the function class. `KeywordCallsites` and `ProtocolCallsites` also contribute static fields.  We'll discuss keyword callsites in [C4: Key in-site]{{site.baseurl}}{% post_url 2025-10-19-key-in-site %}.  We'll discuss protocol callsites in [C4: Is there a protocol for that?]{{site.baseurl}}{% post_url 2025-10-20-is-there-a-protocol-for-that %}.
 
 Let's look at some examples.
 

_posts/2025-10-16-tag-youre-int.md

@@ -13,7 +13,7 @@ Clojurists by nature are type-loose; they'd prefer not to think about types.  Bu
 
 The Clojure compiler computes and propagates type information throughout the abstract syntax tree (AST) as it is constructed. These calculations combine user-supplied type hints,  characteristics of individual functions (return types, signatures of host platform methods), and inherent characteristics of the each basic expression class.
 
-This post explores how typing information is propagated through the AST.  In post [Primitive urges][TBD], we will see how the compiler uses this information to avoid boxing of numeric values.  How reflection is avoided will be covered in [C4: A time for reflection][TBD].
+This post explores how typing information is propagated through the AST.  In post [C4: Primitive urges]({{site.baseurl}}{% post_url 2025-10-17-primitive-urges %}), we will see how the compiler uses this information to avoid boxing of numeric values.  How reflection is avoided will be covered in [C4: A time for reflection][TBD].
 
 ## Just a hint
 
@@ -256,7 +256,7 @@ The only remaining `HostExpr` derivative is `InstanceZeroArityCallExpr`.  This i
 
 That leaves us with `NewExpr`.  For `NewExpr`, we know the type we are creating; that gives us our `ClrType`.  
 
-I'll toss one more in here.  Though not derived from `HostExpr`, `StaticInvokeExpr` is just a special case of `StaticMethodExpr` where the method is an `invokeStatic` on an `IFn`-derived class.  This node type comes up in direct linking of function calls.  For more information, refer to [C4: Functional anatomy]({{site.baseurl}}{% post_url 2025-09-04-functional-anatomy %}) and [C4: fn*: talkin' 'bout my generation][TBD].
+I'll toss one more in here.  Though not derived from `HostExpr`, `StaticInvokeExpr` is just a special case of `StaticMethodExpr` where the method is an `invokeStatic` on an `IFn`-derived class.  This node type comes up in direct linking of function calls.  For more information, refer to [C4: Functional anatomy]({{site.baseurl}}{% post_url 2025-09-04-functional-anatomy %}) and [C4: fn*: talkin' 'bout my generation]({{site.baseurl}}{% post_url 2025-10-15-fn-star-talkin-bout-my-generation %}).
 
 
 ## Symbols and bindings
@@ -348,7 +348,7 @@ _cachedHasType = Tag != null || (Init != null && Init.HasClrType);
 ```
 
 We have a type if either we have a tag or we have an initialization form and _it_ has a type.
-There is a condition above this which negates having a type. In English:  if there is an initialization form, and it has a type and its type is a primitive type (this would have to be a tag on the initialization expression), but the initialization expression is not a `MaybePrimitiveExpr` -- something capable of emitting a primitive value -- then we are in trouble.  We want to hold a primitive value without boxing, but our initialization is at best going to yield a boxed value.  So we say we don't have a type.   We discuss primitive types in great detail in [C4: Primitive urges][TBD].
+There is a condition above this which negates having a type. In English:  if there is an initialization form, and it has a type and its type is a primitive type (this would have to be a tag on the initialization expression), but the initialization expression is not a `MaybePrimitiveExpr` -- something capable of emitting a primitive value -- then we are in trouble.  We want to hold a primitive value without boxing, but our initialization is at best going to yield a boxed value.  So we say we don't have a type.   We discuss primitive types in great detail in [C4: Primitive urges]({{site.baseurl}}{% post_url 2025-10-17-primitive-urges %}).
 
 If we do have a type, a user-supplied tag takes precedence over the type of the initialization expression, per usual.
 
@@ -476,7 +476,7 @@ else
     method._retType = typeof(object);
 ```
 
-By the time you get through this code, `method._retType` is either `typeof(long)`, `typeof(double)`, or `typeof(object)`.  Hmmm.  Where have we seen this combo before?  ODL ... primitive interfaces.  We retain just enough information to calculate which prim interface we should implement.  (See [C4: Primitive urges][TBD].)
+By the time you get through this code, `method._retType` is either `typeof(long)`, `typeof(double)`, or `typeof(object)`.  Hmmm.  Where have we seen this combo before?  ODL ... primitive interfaces.  We retain just enough information to calculate which prim interface we should implement.  (See [C4: Primitive urges]({{site.baseurl}}{% post_url 2025-10-17-primitive-urges %}).)
 
 We've handled:
 
@@ -543,7 +543,7 @@ Does your head hurt yet?  I've been whistling past this graveyard for 15 years.
 
 ## Recur-ing nightmares
 
-We've had enough. I'll put off discussion of how type information plays into `RecurExpr`  until later.  See [C4: Primitive urges][TBD].
+We've had enough. I'll put off discussion of how type information plays into `RecurExpr`  until later.  See [C4: Primitive urges]({{site.baseurl}}{% post_url 2025-10-17-primitive-urges %}).
 
 ## Processing tags
 

_posts/2025-10-17-primitive-urges.md

@@ -49,7 +49,7 @@ A given instance of a `MaybePrimitiveExpr`-implementating class may or may not b
 
 For most of these, the computation of `CanEmitPrimitive` is straightforward.  For example, `NumberExpr` can always emit a primitive value; it can emit only `long` and `double` values.   Whether a `BodyExpr` can emit a primitive value depends on whether its last expression can emit a primitive value.  `HostExpr`-derived classes can emit a primitive value if they are not reflections: we have the explicit `MethodInfo`/`PropertyInfo`/`FieldInfo` to work with and the return type of that is primitive.  Many of the others have an explicit return type calculated; `CanEmitPrimitive` is true if that type is primitive.
 
-The most complicated formula for `CanEmitPrimitive` is in `IfExpr`.  We need both the 'then' and the 'else' expressions to be `MaybePrimitiveExpr`.  They both must have `CanEmitPrimitive` be true, and they must be of the same primitive type -- or one of them can have a return type of type `Recur.RecurType`.  You might recall from [C4: Tag! You're int!][TBD] that `Recur.RecurType` is a special type used as the return type of a `RecurExpr`.  The only reason `RecurExpr` implements `MaybePrimitiveExpr` is to make this code work:
+The most complicated formula for `CanEmitPrimitive` is in `IfExpr`.  We need both the 'then' and the 'else' expressions to be `MaybePrimitiveExpr`.  They both must have `CanEmitPrimitive` be true, and they must be of the same primitive type -- or one of them can have a return type of type `Recur.RecurType`.  You might recall from [C4: Tag! You're int!]({{site.baseurl}}{% post_url 2025-10-16-tag-youre-int %}) that `Recur.RecurType` is a special type used as the return type of a `RecurExpr`.  The only reason `RecurExpr` implements `MaybePrimitiveExpr` is to make this code work:
 
 ```c#
 _thenExpr is MaybePrimitiveExpr tExpr
@@ -291,7 +291,7 @@ Just doing a rough timing in a loop, `calling2` is about 5x as fast as `calling1
 
 ## Intrinsics
 
-Why `fp` has a direct IL `add` instruction but `fb` has to go through `Numbers.add` is a story worthy of its own post.  See [C4: Inline skating][TBD].
+Why `fp` has a direct IL `add` instruction but `fb` has to go through `Numbers.add` is a story worthy of its own post.  See [C4: Inline skating]({{site.baseurl}}{% post_url 2025-10-18-inline-skating %}).
 
 ## CLR considerations
 

_posts/2025-10-18-inline-skating.md

@@ -9,7 +9,7 @@ Inlining allows the compiler to replace some function calls with direct code ins
 
 After the heavy lifting of the last few posts, this post is just a little palate cleanser.
 
-In [C4 - Primitive urges][TBD], we looked at how unnecessary boxing of primitive types can be avoided.  That is accomplished by signficant compiler magic spread over a large number of classes.
+In  [C4: Primitive urges]({{site.baseurl}}{% post_url 2025-10-17-primitive-urges %}), we looked at how unnecessary boxing of primitive types can be avoided.  That is accomplished by signficant compiler magic spread over a large number of classes.
 
 In contrast, inlining and intrinsic operations are very localized and easy to understand.
 
@@ -140,7 +140,7 @@ Inlining will help us.  `f` will compile directly to a call to `clojure.lang.Num
 
 There are a lot of overloads of `Numbers.add` to handle different types of arguments.  In this case, because we do not have more specific type information about `x` and `y`, we will end up calling the version that takes two `object` arguments.  This will result in boxing if `x` and `y` are primitive type values, and a bunch of type checking and dispatching inside `Numbers.add`.
 
-We learned in  [C4 - Primitive urges][TBD] how to avoid boxing.  If we restrict the types of `x` and `y` to, say, `double`, we can avoid boxing:
+We learned in  [C4: Primitive urges]({{site.baseurl}}{% post_url 2025-10-17-primitive-urges %}) how to avoid boxing.  If we restrict the types of `x` and `y` to, say, `double`, we can avoid boxing:
 
 
 ```clojure