Enable syntax highlighting with tree-sitter

Author: hedyhli

Makefile

@@ -0,0 +1,16 @@
+AWK=awk
+HUGO=hugo
+
+.PHONY: build
+build:
+	$(HUGO)
+	make public/*.html
+	make public/**/*.html
+
+public/%.html: .FORCE
+	@mv $@ tmp.html
+	$(AWK) -v outfile=$@ -f scripts/process-code-blocks.awk tmp.html
+	@rm tmp.html
+
+.PHONY: .FORCE
+.FORCE:

content/_index.md

@@ -7,7 +7,7 @@ title = 'About'
 
 ## Readable and concise concatenative programming
 
-```
+```cognate
 ~~ Fizzbuzz in Cognate
 
 Def Multiple as (Zero? Modulo);
@@ -23,7 +23,7 @@ For each in Range 1 to 100 (Print Fizzbuzz)
 
 Cognate is a project aiming to create a human readable programming language with as little syntax as possible. Where natural language programming usually uses many complex syntax rules, instead Cognate takes them away. What it adds is simple, a way to embed comments into statements.
 
-```
+```cognate
 ~~ Towers of Hanoi in Cognate
 
 Def Move discs as (
@@ -45,7 +45,7 @@ Move 5 discs from "a" via "b" to "c"
 
 As you can see, Cognate ignores words starting with lowercase letters, allowing them to be used to describe functionality and enhance readability. This makes Cognate codebases intuitive and maintainable.
 
-```
+```cognate
 ~~ Square numbers in Cognate
 
 Def Square as (* Twin);
@@ -55,7 +55,7 @@ Print
 
 Cognate is a stack-oriented programming language similar to Forth or Factor, except statements are evaluated right to left. This gives the expressiveness of concatenative programming as well as the readability of prefix notation. Statements can be delimited at arbitrary points, allowing them to read as sentences would in English.
 
-```
+```cognate
 ~~ Prime numbers in Cognate
 
 Def Factor (Zero? Modulo Swap);

content/learn.md

@@ -29,13 +29,13 @@ Alternatively, you can use the interactive web playground [here](https://cognate
 ## First Programs
 
 
-```
+```cognate
 Print "Hello world!";
 ```
 
 Fairly simple right? This example calls the `Print` function with one parameter - the string `"Hello world!"`. Now let's do another simple example, adding two numbers.
 
-```
+```cognate
 Print + 2 3;
 ```
 
@@ -45,7 +45,7 @@ Wait what? That isn't how maths works!
 Cognate doesn't care how maths works. Where in most programming languages, `+` would be an operator and would be used in the infix position, in Cognate `+` is a function. Like `Print`, the `+` function is called by being written before its arguments like shown above.
 
 
-```
+```cognate
 Print - 10 36; ~~ Subtracts 10 from 36
 ```
 
@@ -55,7 +55,7 @@ Another thing to note is that the order of parameters for `-` and `/` are backwa
 
 Let's have a more complex example, this subtracts 12 from 15 and then multiplies the result by 2.
 
-```
+```cognate
 Print * 2 - 12 15;
 ```
 
@@ -71,7 +71,7 @@ By now you may have realised that Cognate is evaluating our programs backwards -
 
 Cognate comes with functions to manipulate the stack. The simplest of these is `Twin`, which takes the top element from the stack, and puts it back on again - twice. The below snippet uses `Twin` to square a number by multiplying it by itself.
 
-```
+```cognate
 Print * Twin 8;
 ```
 
@@ -81,14 +81,14 @@ Now we don't want to write this every time we square a number right? So let's cr
 
 Functions in Cognate are defined using `Def` and the name of the function. The function body is put in brackets after this.
 
-```
+```cognate
 Def Square (* Twin);
 Print Square 8;
 ```
 
 This is great, but it certainly could flow better. Cognate ignores words starting with lowercase letters, allowing them to be used as comments. This lets us write:
 
-```
+```cognate
 Print the Square of 8;
 ```
 
@@ -98,19 +98,19 @@ In this example the readability isn't really improved much, but in more complex
 By now you've probably noticed the semicolons. These delimit statements so that Cognate knows what order to evaluate functions in (remember that these are executed backwards). Definitions should also be terminated with semicolons. The stack persists between statements, letting us do things like this.
 
 
-```
+```cognate
 8 ; Square ; Print ;
 ```
 
 or this
 
-```
+```cognate
 Square 8 ; Print ;
 ```
 
 or this
 
-```
+```cognate
 8 ; Print the Square ;
 ```
 
@@ -120,14 +120,14 @@ This flexible syntax allows Cognate programs to flow as if written in sentences.
 
 Variables are defined in a fairly similar manner to functions using `Let` and their name. This takes a value from the stack, binding it to this name. Variables are referenced with the same syntax in which functions are called.
 
-```
+```cognate
 Let X be 4;
 Print X;
 ```
 
 We can use variables to define functions that take named parameters - here's an alternate version of the `Square` function.
 
-```
+```cognate
 Def Square as (
    Let X;
    * X X
@@ -136,7 +136,7 @@ Def Square as (
 
 Notice that the last statement before a closing bracket does not need to be terminated with a semicolon. Also there is no return statement, since values are implicitly returned on the stack. This means we can actually define functions that return multiple values, such as the `Twin` function we saw earlier.
 
-```
+```cognate
 Def Twin as (
    Let X;
    X X
@@ -148,23 +148,23 @@ Def Twin as (
 
 Like most programming languages, Cognate has if statements and loops and all that jazz. The simplest form of control flow is `When`, which simply executes a block of code if given `True` or not if `False`.
 
-```
+```cognate
 When == 1 1 (
    Print "Who'd have guessed?"
 );
 ```
 
 There is also `Unless` that evaluates the block if given `False`. `While` takes a condition in brackets and evaluates the block of code until the condition is `False`. `Until`, you guessed it, is the opposite of `While` and runs until the condition is `True`.
 
-```
+```cognate
 While (True) (
    Print "This may well print forever"
 );
 ```
 
 What's with the second set of brackets? `When` doesn't have them, so why should `While`? This is because brackets denote blocks! These prevent code being instantly evaluated and instead push a reference onto the stack. Blocks also control variable scopes. We can evaluate a block using the `Do` function - which is how our control flow functions are implemented.
 
-```
+```cognate
 Do (
    Print "Hello from inside a block!"
 );
@@ -176,7 +176,7 @@ This explains the syntax for functions: `Def` simply binds a block to a name, mu
 Now that this (hopefully) makes some sense, we can finally introduce the `If` statement! `If` is a function that takes three parameters. The first is a boolean, if this is `True` then the second argument is returned. If not, the third argument is returned. We can chain `If`s together to have more complex control flow.
 
 
-```
+```cognate
 Print
    If == X 1 then "foo"
    If == X 2 then "bar"
@@ -185,7 +185,7 @@ Print
 
 We can combine this with `Do` to have conditional code execution.
 
-```
+```cognate
 Do
    If == X 1 then ( Print "foo" )
    If == X 2 then ( Print "bar" )
@@ -194,7 +194,7 @@ Do
 
 Now, lets use our knowledge of blocks to define our own control flow function `Thrice`, which should evaluate a block three times in a row. This demonstrates a different use of `Def` in which we bind a block from the stack.
 
-```
+```cognate
 Def Thrice as (
    Def F;
    F F F
@@ -207,7 +207,7 @@ Thrice (
 
 A more general version of this function, `Times` can be defined using recursion.
 
-```
+```cognate
 Def Times (
 	Let N number of repetitions;
 	Def F function to repeat;
@@ -221,7 +221,7 @@ Times 5 (
 
 Now you may see a small problem with this. If the user calls `Times` with a non-integer parameter it will loop forever - that won't do at all! We use the `Integer!` function to throw a type error if a decimal is given.
 
-```
+```cognate
 Def Times (
 	Let N is Integer! number of repetitions;
 	Def F function to repeat;
@@ -235,7 +235,7 @@ We could also use the `Block!` function for `F` but we'll already get a type err
 The `Times` function is also our first loop. We don't need to define it every time though as it's also in the standard library. Another loop is `While`.
 
 
-```
+```cognate
 While (!= "done" Twin Input) (
   Print
 );
@@ -252,13 +252,13 @@ This loop is most useful in imperative code where intermediary values are passed
 
 In Cognate, lists are generated using - you guessed it - a function. The `List` function takes a block as a parameter. It evaluates this block *in a new stack* and then returns that stack as a list.
 
-```
+```cognate
 Print List (1 2 3 4 5);
 ```
 
 This allows Cognate's list creation to be much more flexible than other languages - for example what if we wanted a list of 100 ones?
 
-```
+```cognate
 Print List ( Times 100 (1) );
 ```
 
@@ -268,37 +268,37 @@ The three most fundamental list functions are `Push`, `First`, and `Rest`.
  The `Push` function takes a value and a list as parameters, and returns the list with the value *pushed* to it's first element. `First` simply returns the first element of a list. `Rest` returns a list without its first element.
 
 
-```
+```cognate
 Let L be Push "foo" to List ( "bar" "baz" );
 Print First element of L;
 Print Rest of L;
 ```
 
 `Range` creates a list of numbers from a starting (inclusive) and an ending (exclusive) number. `For` is a higher order function that applied an operation to each element of a list - it is the loop for iterating over lists.
 
-```
+```cognate
 Def Square as (* Twin);
 For each in Range 1 to 20 (Print the Square);
 ```
 
 `Map` is like `For` but the result of the computation is stored in a new list.
 
-```
+```cognate
 Let Evens be Map (* 2) over Range 1 to 50;
 Print Evens;
 ```
 
 `Filter` applies a function to each element of a list also. This function should return a boolean - if this is `False` then the function is removed from the returned list.
 
-```
+```cognate
 Let Even? be (Zero? Modulo 2);
 Let Evens be Filter (Even?) over Range 1 to 100;
 Print Evens;
 ```
 
 The functional programmers reading this are likely expecting a Fold or Reduce function next - which applies an operation to a list with an accumulator. However Cognate needs no fold function, as `For` can store intermediary values on the stack, acting like a fold.
 
-```
+```cognate
 Def Factorial as (
    Let N be Integer!;
    For each in Range 1 to N (*) from 1;
@@ -316,7 +316,7 @@ While storing state between loop iterations is very useful, in some cases you ju
  The `Box` function takes a value and places it in a box. `Unbox` returns the item stored in a box. `Set` takes a box and a value as parameters and mutates the box to hold the value, updating all references to it.
 
 
-```
+```cognate
 Let X be Box 1;
 Print Unbox X; ~~ prints 1
 
@@ -326,7 +326,7 @@ Print Unbox X; ~~ prints 2
 
 Boxes aren't limited to mutating variables, they can be used for any value.
 
-```
+```cognate
 Let L be Map (Box) over Range 1 to 10;
 Print L;
 
@@ -339,7 +339,7 @@ Print L;
 
 While boxes may not seem as ergonomic as mutation in other languages, they are both more flexible than mutable variables and more predictable than implicit references. We can also easily extend mutation, like this:
 
-```
+```cognate
 Def Box-list as ( Map (Box) );
 
 Def Inplace-map as (

layouts/_default/_markup/render-codeblock-cognate.html

@@ -0,0 +1,3 @@
+{{ printf "<!--cognate-->" | safeHTML }}<div class="code"><pre><code>
+{{ .Inner | safeHTML }}
+</code></pre></div>

public/categories/index.xml

@@ -4,7 +4,8 @@
     <title>Categories on Cognate: Readable and concise concatenative programming</title>
     <link>https://cognate-lang.github.io/categories/</link>
     <description>Recent content in Categories on Cognate: Readable and concise concatenative programming</description>
-    <generator>Hugo -- gohugo.io</generator>
-    <language>en-us</language><atom:link href="https://cognate-lang.github.io/categories/index.xml" rel="self" type="application/rss+xml" />
+    <generator>Hugo</generator>
+    <language>en-us</language>
+    <atom:link href="https://cognate-lang.github.io/categories/index.xml" rel="self" type="application/rss+xml" />
   </channel>
 </rss>