From b547171a325262250d7fd74ec263ae1df9eb814a Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 09:40:32 +0200
Subject: [PATCH 01/17] Create christiaanbaaij.json

---
 data/authors/christiaanbaaij.json | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 data/authors/christiaanbaaij.json

diff --git a/data/authors/christiaanbaaij.json b/data/authors/christiaanbaaij.json
new file mode 100644
index 0000000..688ad92
--- /dev/null
+++ b/data/authors/christiaanbaaij.json
@@ -0,0 +1,10 @@
+{
+    "name": "Christiaan Baaij",
+    "bio": "Christiaan Baaij is one of the initial developers of the Clash compiler.",
+    "image": "/media/authors/christiaanbaaij.jpg",
+    "weight": 1,
+    "social": {
+        "twitter": "christiaanbaaij",
+        "github": "https://www.github.com/christiaanb"
+    }
+}

From 81d95acdec75d73097e928f1b84ba9deb5bd8b99 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 09:43:18 +0200
Subject: [PATCH 02/17] Add christiaanbaaij.jpg

---
 static/media/authors/christiaanbaaij.jpg | Bin 0 -> 16449 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 static/media/authors/christiaanbaaij.jpg

diff --git a/static/media/authors/christiaanbaaij.jpg b/static/media/authors/christiaanbaaij.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..af78be1f4a04e8df6e3e985e24cd7c4988b243a9
GIT binary patch
literal 16449
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

literal 0
HcmV?d00001


From dcbe05f8dc03ca6019f6a87d697dfc63982d50a3 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 10:24:54 +0200
Subject: [PATCH 03/17] Create 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 content/blog/0006-linear-clash.md

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
new file mode 100644
index 0000000..ea0634e
--- /dev/null
+++ b/content/blog/0006-linear-clash.md
@@ -0,0 +1,18 @@
+---
+title: "Clash's case for linear types in Haskell"
+date: "2019-06-11"
+description: "What it says on the tin"
+disable_comments: false
+author: "martijnbastiaan"
+authorbox: true # Optional, enable authorbox for specific post
+summary: Linear types are hopefully to hit GHC imminent, here we present Clash's use case for them. 
+toc: false
+mathjax: false
+---
+
+I'm writing this post on the train on my way back from an amazing ZuriHac 2019, where I got to meet a lot of new people, many of them really excited about Clash!
+I also got to talk with some about the linear types feature that will hopefully hit GHC HEAD very soon.
+There were some thoughts floating around in my head on how to use linear types (not "original" thoughts, but I'll get to that later) for Clash, but wasn't really sure how the linear arrows approach would actually fit.
+But thanks to the helpful explanations of Araud, Csongor, Krzysztof, and Simon, I finally understand how linear arrows work, and _why_ they would work for Clash!
+Getting back to the 'not original thoughts', it was actually the work of [Dan Ghica](http://www.cs.bham.ac.uk/~drg/papers.html) on "Geometry of Synthesis (GoS)" that introduced me to the idea of how linear types (GoS actually uses affine types) and hardware fit together.
+

From 8498bdcb8f5b7ed8887dc0d4ba18ca2efdf7b4f6 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 11:31:52 +0200
Subject: [PATCH 04/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index ea0634e..f89ee1e 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -14,5 +14,5 @@ I'm writing this post on the train on my way back from an amazing ZuriHac 2019,
 I also got to talk with some about the linear types feature that will hopefully hit GHC HEAD very soon.
 There were some thoughts floating around in my head on how to use linear types (not "original" thoughts, but I'll get to that later) for Clash, but wasn't really sure how the linear arrows approach would actually fit.
 But thanks to the helpful explanations of Araud, Csongor, Krzysztof, and Simon, I finally understand how linear arrows work, and _why_ they would work for Clash!
-Getting back to the 'not original thoughts', it was actually the work of [Dan Ghica](http://www.cs.bham.ac.uk/~drg/papers.html) on "Geometry of Synthesis (GoS)" that introduced me to the idea of how linear types (GoS actually uses affine types) and hardware fit together.
+Getting back to the 'not original thoughts', it was actually the work of [Dan Ghica](http://www.cs.bham.ac.uk/~drg/papers.html) on "Geometry of Synthesis (GoS)" that introduced me to the idea of how linear types (GoS actually uses affine types) and hardware fit together, and so many of the concepts in this blog post can be found in the GoS papers ([1](http://www.cs.bham.ac.uk/~drg/papers/popl07x.pdf), [2](http://www.cs.bham.ac.uk/~drg/papers/mfps10.pdf), [3](http://www.cs.bham.ac.uk/~drg/papers/popl11.pdf), [4](http://www.cs.bham.ac.uk/~drg/papers/icfp11.pdf), [5](http://www.cs.bham.ac.uk/~drg/papers/lics09tut.pdf), [6](http://www.cs.bham.ac.uk/~drg/papers/memocode11.pdf)) in one shape or form.
 

From cefca66df79c63a3347a3c04cc7ba4b64350882d Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 12:02:50 +0200
Subject: [PATCH 05/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index f89ee1e..495921e 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -3,7 +3,7 @@ title: "Clash's case for linear types in Haskell"
 date: "2019-06-11"
 description: "What it says on the tin"
 disable_comments: false
-author: "martijnbastiaan"
+author: "christiaanbaaij"
 authorbox: true # Optional, enable authorbox for specific post
 summary: Linear types are hopefully to hit GHC imminent, here we present Clash's use case for them. 
 toc: false
@@ -16,3 +16,29 @@ There were some thoughts floating around in my head on how to use linear types (
 But thanks to the helpful explanations of Araud, Csongor, Krzysztof, and Simon, I finally understand how linear arrows work, and _why_ they would work for Clash!
 Getting back to the 'not original thoughts', it was actually the work of [Dan Ghica](http://www.cs.bham.ac.uk/~drg/papers.html) on "Geometry of Synthesis (GoS)" that introduced me to the idea of how linear types (GoS actually uses affine types) and hardware fit together, and so many of the concepts in this blog post can be found in the GoS papers ([1](http://www.cs.bham.ac.uk/~drg/papers/popl07x.pdf), [2](http://www.cs.bham.ac.uk/~drg/papers/mfps10.pdf), [3](http://www.cs.bham.ac.uk/~drg/papers/popl11.pdf), [4](http://www.cs.bham.ac.uk/~drg/papers/icfp11.pdf), [5](http://www.cs.bham.ac.uk/~drg/papers/lics09tut.pdf), [6](http://www.cs.bham.ac.uk/~drg/papers/memocode11.pdf)) in one shape or form.
 
+# Synthesis of higher-order functions
+
+Given a function:
+
+{{< highlight haskell >}}
+f :: Int32 -> Int32 -> Bool
+{{< / highlight >}}
+
+Clash will convert this to a circuit with two 32-bit input ports, corresponding to the two `Int32` arguments, and a 1-bit output port, corresponding to the `Bool` result.
+That is, Clash will create a circuit from a function where the function's arguments are transformed to input ports, and the result of the function is mapped to an output port.
+And then when a function is called, the circuits corresponding to the applied arguments are connected to the input ports, and the output port is connected to the circuits corresponding to the expressions using the result of the (fully) applied circuit.
+
+In many situations this is a straightforwared prcoess, but what happens when one of the arguments has a function type?
+
+{{< highlight haskell >}}
+f :: (Int32 -> Int32) -> Int32 -> Bool
+f h y = (h y) < 10
+
+g :: Int32 -> Bool
+g x = f k x
+
+k :: Int32 -> Int32
+{{< / highlight >}}
+
+How many bits are needed for a port of type `(Int32 -> Int32)`? How would the input port `y` corresponding to hook up to the input port corresponding to `h`? How, inside `g`, do we hook up the input ports of `k` to the input port to the input port `h`?
+Clearly this idea of mapping arguments to input ports, and results to output ports, doesn't work when our arguments have a function type.

From 3b3a43437f7c2bca9265204c8c2a1141775e4e46 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 12:26:34 +0200
Subject: [PATCH 06/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index 495921e..fc20a1e 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -34,11 +34,25 @@ In many situations this is a straightforwared prcoess, but what happens when one
 f :: (Int32 -> Int32) -> Int32 -> Bool
 f h y = (h y) < 10
 
-g :: Int32 -> Bool
-g x = f k x
-
 k :: Int32 -> Int32
+
+topEntity :: Int32 -> Bool
+topEntity x = f k x
 {{< / highlight >}}
 
 How many bits are needed for a port of type `(Int32 -> Int32)`? How would the input port `y` corresponding to hook up to the input port corresponding to `h`? How, inside `g`, do we hook up the input ports of `k` to the input port to the input port `h`?
-Clearly this idea of mapping arguments to input ports, and results to output ports, doesn't work when our arguments have a function type.
+Clearly this idea of mapping arguments to input ports, and results to output ports, doesn't work when our arguments have a function type. So how does Clash handle this? Well, before converting the expressions to a circuit, uses a process called specialisation to transform the above code to:
+
+{{< highlight haskell >}}
+fK :: Int32 -> Bool
+fK y = (k y) < 10
+
+k :: Int32 -> Int32
+
+topEntity :: Int32 -> Bool
+topEntity x = fK x
+{{< / highlight >}}
+
+resulting in a collection of functions where none of them have an argument with a function type; and so the idea of mapping arguments to input ports, and results to output works, will work again.
+This specialisation process will always succeed as long as `topEntity` doesn't have any arguments with a function type.
+And in the case that `topEntity` does have arguments with a function type, Clash gives up immediately and reports to the user that their code cannot be translated into a circuit. 

From 5b0c84af25c791e668cc23db77572e611649e267 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 12:53:01 +0200
Subject: [PATCH 07/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index fc20a1e..7121c3e 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -55,4 +55,13 @@ topEntity x = fK x
 
 resulting in a collection of functions where none of them have an argument with a function type; and so the idea of mapping arguments to input ports, and results to output works, will work again.
 This specialisation process will always succeed as long as `topEntity` doesn't have any arguments with a function type.
-And in the case that `topEntity` does have arguments with a function type, Clash gives up immediately and reports to the user that their code cannot be translated into a circuit. 
+And in the case that `topEntity` does have arguments with a function type, Clash gives up immediately and reports to the user that their code cannot be translated into a circuit.
+
+# Synchronisation and the case for a higher-order top-level functions
+You might argue that a first-order top-level function (`topEntity`) is a sensible restriction, after all, it's kind of the "entry point" into your entire circuit (much like `main :: IO ()` in regular Haskell program).
+So what use would we have for a higher-order `topEnity`?
+
+One such case is when your circuit is communicating with peripherals that have an explicit synchronisation, whether it be an _acknowledge_, _ready_, or _wait_ signal, and both in case your circuit is producing that synchronisation signal or consuming that synchronistation signal.
+In these cases, when you're producing data, then this data is part of the result of your `topEntity`, corresponding to an output port, and the synchronistation channel becomes an argument, corresponding to an input.
+When you're consuming data, then this data becomes an argument, corresponding to an output port, and the synchronistation channel becomes part of the result, corresponding to an output port.
+Now imagine that your circuit is communicating with six peripherals.

From 8ff919e2562de72ae36dd2a299c27337f1bdc499 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 13:24:25 +0200
Subject: [PATCH 08/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index 7121c3e..4032b08 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -65,3 +65,28 @@ One such case is when your circuit is communicating with peripherals that have a
 In these cases, when you're producing data, then this data is part of the result of your `topEntity`, corresponding to an output port, and the synchronistation channel becomes an argument, corresponding to an input.
 When you're consuming data, then this data becomes an argument, corresponding to an output port, and the synchronistation channel becomes part of the result, corresponding to an output port.
 Now imagine that your circuit is communicating with six peripherals.
+With a first-order restriction on your `topEntity`, the only way to implement this is to have something like:
+
+{{< highlight haskell >}}
+topEntity :: DataIn1 -> DataIn2 -> SyncIn3 -> DataIn4 -> (SyncOut1, SyncOut2, DataOut3, SyncIn4)
+topEntity d1 d2 s3 d4 = (s1, s2, d3, s4)
+ where
+  ...
+{{< / highlight >}}
+
+where the data and synchronisation part of a channel become syntactically seperated, and you'll quickly use the overview of what's going on.
+It becomes worse when you get to protocols like AXI4, where you're the consumer of some data, and the producer of some other data.
+
+The interface just becomes so much nice if you could simply write:
+
+{{< highlight haskell >}}
+type DataConsumer1 = DataIn1 -> SyncOut1
+type DataConsumer2 = DataIn2 -> SyncOut2
+type DataProducer3 = SyncIn3 -> DataOut3
+type DataConsumer4 = DataIn4 -> SyncOut4
+
+topEntity :: DataConsumer1 -> DataConsumer2 -> DataProducer3 -> DataConsumer4
+topEntity c1 c2 p3 = c4
+ where
+  ...
+{{< / highlight >}}

From 6bf857e79f8dd15655c7bfc6daf17df3d51ecee9 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 13:36:45 +0200
Subject: [PATCH 09/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index 4032b08..04f1ea9 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -64,11 +64,11 @@ So what use would we have for a higher-order `topEnity`?
 One such case is when your circuit is communicating with peripherals that have an explicit synchronisation, whether it be an _acknowledge_, _ready_, or _wait_ signal, and both in case your circuit is producing that synchronisation signal or consuming that synchronistation signal.
 In these cases, when you're producing data, then this data is part of the result of your `topEntity`, corresponding to an output port, and the synchronistation channel becomes an argument, corresponding to an input.
 When you're consuming data, then this data becomes an argument, corresponding to an output port, and the synchronistation channel becomes part of the result, corresponding to an output port.
-Now imagine that your circuit is communicating with six peripherals.
+Now imagine that your circuit is communicating with four peripherals, with 3 peripherals producing data, and 1 consuming data.
 With a first-order restriction on your `topEntity`, the only way to implement this is to have something like:
 
 {{< highlight haskell >}}
-topEntity :: DataIn1 -> DataIn2 -> SyncIn3 -> DataIn4 -> (SyncOut1, SyncOut2, DataOut3, SyncIn4)
+topEntity :: Data1 -> Data2 -> Sync3 -> Data4 -> (Sync1, Sync2, Data3, Sync4)
 topEntity d1 d2 s3 d4 = (s1, s2, d3, s4)
  where
   ...
@@ -77,16 +77,18 @@ topEntity d1 d2 s3 d4 = (s1, s2, d3, s4)
 where the data and synchronisation part of a channel become syntactically seperated, and you'll quickly use the overview of what's going on.
 It becomes worse when you get to protocols like AXI4, where you're the consumer of some data, and the producer of some other data.
 
-The interface just becomes so much nice if you could simply write:
+The interface just becomes so much nicer if you could simply write:
 
 {{< highlight haskell >}}
-type DataConsumer1 = DataIn1 -> SyncOut1
-type DataConsumer2 = DataIn2 -> SyncOut2
-type DataProducer3 = SyncIn3 -> DataOut3
-type DataConsumer4 = DataIn4 -> SyncOut4
+type DataProducer1 = Sync1 -> Data1
+type DataProducer2 = Sync2 -> Data2
+type DataConsumer3 = Data3 -> Sync3
+type DataProducer4 = Sync4 -> Data4
 
-topEntity :: DataConsumer1 -> DataConsumer2 -> DataProducer3 -> DataConsumer4
+topEntity :: DataProducer1 -. DataProducer2 -. DataConsumer3 -. DataConsumer4
 topEntity c1 c2 p3 = c4
  where
   ...
 {{< / highlight >}}
+
+Also note that it's impossible to convert between the two, and so we really need linear types for the above API to work safely.

From cd00a5d4592bb5f18d1fd5e73f0024ba36c76531 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 14:27:19 +0200
Subject: [PATCH 10/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 36 ++++++++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index 04f1ea9..7d09cb3 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -10,6 +10,8 @@ toc: false
 mathjax: false
 ---
 
+__TL;DR Consuming a function linearly means consuming the function's argument linearly, which at the circuit-level means that the output port of a higher-order argument is only driven by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. the higher-order arguments of the very top of our function hierarcy.__
+
 I'm writing this post on the train on my way back from an amazing ZuriHac 2019, where I got to meet a lot of new people, many of them really excited about Clash!
 I also got to talk with some about the linear types feature that will hopefully hit GHC HEAD very soon.
 There were some thoughts floating around in my head on how to use linear types (not "original" thoughts, but I'll get to that later) for Clash, but wasn't really sure how the linear arrows approach would actually fit.
@@ -57,7 +59,39 @@ resulting in a collection of functions where none of them have an argument with
 This specialisation process will always succeed as long as `topEntity` doesn't have any arguments with a function type.
 And in the case that `topEntity` does have arguments with a function type, Clash gives up immediately and reports to the user that their code cannot be translated into a circuit.
 
-# Synchronisation and the case for a higher-order top-level functions
+# Synthesis of higher order functions, take 2
+So what if we really wanted a higher-order `topEntity`, how could we then proceed?
+Now the following concept is exactly described in the Geometry of Synthesis papers, for any argument with a function type:
+
+* The function arguments become output ports,
+* and the function result becomes an output port,
+* and if any of the arguments are themself higher-order then the "polarity" inside of them will be switched again.
+
+So in:
+
+{{< highlight haskell >}}
+f :: (Int32 -> Int32) -> Int32 -> Bool
+f h y = (h y) < 10
+
+k :: Int32 -> Int32
+
+topEntity :: Int32 -> Bool
+topEntity x = f k x
+{{< / highlight >}}
+
+the component for `f` would get: 
+
+* an additional `Int32` input port corresponding to the result of the `h` argument, 
+* and an additional `Int32` output port corresponding to the argument of `h`.
+
+Inside the component for `f` we would then:
+
+* connect the input port corresponding to `y` to the output port corresponding to `h`s argument,
+* and connect the input port corresponding to `h`s result to the left input of the `<` component.
+
+Inside `topEntity`
+
+# Synchronisation and the case for higher-order top-level functions
 You might argue that a first-order top-level function (`topEntity`) is a sensible restriction, after all, it's kind of the "entry point" into your entire circuit (much like `main :: IO ()` in regular Haskell program).
 So what use would we have for a higher-order `topEnity`?
 

From 905ed3ef3f27a721db6feb2b5f1e1068f70b7284 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 14:51:38 +0200
Subject: [PATCH 11/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index 7d09cb3..bc0fecc 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -10,7 +10,7 @@ toc: false
 mathjax: false
 ---
 
-__TL;DR Consuming a function linearly means consuming the function's argument linearly, which at the circuit-level means that the output port of a higher-order argument is only driven by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. the higher-order arguments of the very top of our function hierarcy.__
+__TL;DR Consuming a function linearly means consuming the function's argument linearly, which in a circuit context means that the output port of a higher-order argument is only driven/written by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to our circuit.__
 
 I'm writing this post on the train on my way back from an amazing ZuriHac 2019, where I got to meet a lot of new people, many of them really excited about Clash!
 I also got to talk with some about the linear types feature that will hopefully hit GHC HEAD very soon.
@@ -89,7 +89,28 @@ Inside the component for `f` we would then:
 * connect the input port corresponding to `y` to the output port corresponding to `h`s argument,
 * and connect the input port corresponding to `h`s result to the left input of the `<` component.
 
-Inside `topEntity`
+Inside `topEntity`, we would then:
+
+* Connect the input port of `k` to the output port of `f` that corresponds to the argument of `h`,
+* and connect the ouptput port of `k` to the input port of `f` that corresponds to the result of `h`.
+
+_TODO: create a picture making the above more intuiative._
+
+# Consuming functions linearly
+
+Now let's say we change our definition of `f` to:
+
+{{< highlight haskell >}}
+f :: (Int32 -> Int32) -> Int32 -> Int -> Bool
+f h x y = (h x + h y) < 10
+{{< / highlight >}}
+
+i.e. apply the function `h` twice to different arguments.
+If we would keep the same translation, then the input port corresponding the the result of `h` would be connected to the input ports of the `+` component.
+There are no issues here, a source can drive/write multiple sinks.
+The catastropic issue is that the output port corresponding to the argument of `h` is now being driven/written by the input ports corresponding to `x` and `y`: a sink should only be driven/written by a single source!
+
+_TODO: create a picture making the above more intuiative._
 
 # Synchronisation and the case for higher-order top-level functions
 You might argue that a first-order top-level function (`topEntity`) is a sensible restriction, after all, it's kind of the "entry point" into your entire circuit (much like `main :: IO ()` in regular Haskell program).

From 51e6b7b3eca9065104ef046de37b38ed413551e1 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 15:37:21 +0200
Subject: [PATCH 12/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index bc0fecc..3753ff9 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -10,7 +10,7 @@ toc: false
 mathjax: false
 ---
 
-__TL;DR Consuming a function linearly means consuming the function's argument linearly, which in a circuit context means that the output port of a higher-order argument is only driven/written by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to our circuit.__
+__TL;DR Consuming a function linearly means consuming the function's argument linearly, which in a circuit context means that the output port of a higher-order argument is only driven/written by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to the circuit.__
 
 I'm writing this post on the train on my way back from an amazing ZuriHac 2019, where I got to meet a lot of new people, many of them really excited about Clash!
 I also got to talk with some about the linear types feature that will hopefully hit GHC HEAD very soon.

From cc889b861a9dd5414c177637250a176cb0893410 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 15:50:08 +0200
Subject: [PATCH 13/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index 3753ff9..a506306 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -112,6 +112,11 @@ The catastropic issue is that the output port corresponding to the argument of `
 
 _TODO: create a picture making the above more intuiative._
 
+There are two options here:
+
+1. Duplicate the output (and input) ports of the `h` argument so that `x` and `y` can be connected to these outputs seperately; this behaviour basically corresponds to the specialisation transformation Clash applies already.
+2. Use linear arrows
+
 # Synchronisation and the case for higher-order top-level functions
 You might argue that a first-order top-level function (`topEntity`) is a sensible restriction, after all, it's kind of the "entry point" into your entire circuit (much like `main :: IO ()` in regular Haskell program).
 So what use would we have for a higher-order `topEnity`?

From 4ab4fe05c545c5f0100678bb619d77a9873365a4 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 15:55:59 +0200
Subject: [PATCH 14/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index a506306..bfddc1f 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -10,7 +10,7 @@ toc: false
 mathjax: false
 ---
 
-__TL;DR Consuming a function linearly means consuming the function's argument linearly, which in a circuit context means that the output port of a higher-order argument is only driven/written by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to the circuit.__
+__TL;DR What does it mean for a function to be used linearly? It means that it's argument will be used linearly. Somewhat surprisingly, in a circuit context it means that the output port of a higher-order argument is only driven by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to the circuit.__
 
 I'm writing this post on the train on my way back from an amazing ZuriHac 2019, where I got to meet a lot of new people, many of them really excited about Clash!
 I also got to talk with some about the linear types feature that will hopefully hit GHC HEAD very soon.

From bf369d3eac083a431fa2b7eaa332a1635489082b Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 16:01:53 +0200
Subject: [PATCH 15/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index bfddc1f..0361ae9 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -10,7 +10,7 @@ toc: false
 mathjax: false
 ---
 
-__TL;DR What does it mean for a function to be used linearly? It means that it's argument will be used linearly. Somewhat surprisingly, in a circuit context it means that the output port of a higher-order argument is only driven by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to the circuit.__
+__TL;DR What does it mean for a function to be used linearly? It means that it's _argument_ will be used linearly. Somewhat surprisingly, in a circuit context it means that the _output port_ of a higher-order argument is only driven by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to the circuit.__
 
 I'm writing this post on the train on my way back from an amazing ZuriHac 2019, where I got to meet a lot of new people, many of them really excited about Clash!
 I also got to talk with some about the linear types feature that will hopefully hit GHC HEAD very soon.
@@ -30,7 +30,7 @@ Clash will convert this to a circuit with two 32-bit input ports, corresponding
 That is, Clash will create a circuit from a function where the function's arguments are transformed to input ports, and the result of the function is mapped to an output port.
 And then when a function is called, the circuits corresponding to the applied arguments are connected to the input ports, and the output port is connected to the circuits corresponding to the expressions using the result of the (fully) applied circuit.
 
-In many situations this is a straightforwared prcoess, but what happens when one of the arguments has a function type?
+In many situations this is a straightforward process, but what happens when one of the arguments has a function type?
 
 {{< highlight haskell >}}
 f :: (Int32 -> Int32) -> Int32 -> Bool
@@ -64,7 +64,7 @@ So what if we really wanted a higher-order `topEntity`, how could we then procee
 Now the following concept is exactly described in the Geometry of Synthesis papers, for any argument with a function type:
 
 * The function arguments become output ports,
-* and the function result becomes an output port,
+* and the function result becomes an input port,
 * and if any of the arguments are themself higher-order then the "polarity" inside of them will be switched again.
 
 So in:

From d04c69d587526f50276b752204e317e76da6addc Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 16:08:23 +0200
Subject: [PATCH 16/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 34 +++++++++++++++----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index 0361ae9..400b2d4 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -10,7 +10,7 @@ toc: false
 mathjax: false
 ---
 
-__TL;DR What does it mean for a function to be used linearly? It means that it's _argument_ will be used linearly. Somewhat surprisingly, in a circuit context it means that the _output port_ of a higher-order argument is only driven by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to the circuit.__
+__TL;DR What does it mean for a function to be used linearly? It means that function's _argument_ will be used linearly. Somewhat surprisingly, in a circuit context it means that the _output port_ of a higher-order argument is only driven by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to the circuit.__
 
 I'm writing this post on the train on my way back from an amazing ZuriHac 2019, where I got to meet a lot of new people, many of them really excited about Clash!
 I also got to talk with some about the linear types feature that will hopefully hit GHC HEAD very soon.
@@ -33,12 +33,12 @@ And then when a function is called, the circuits corresponding to the applied ar
 In many situations this is a straightforward process, but what happens when one of the arguments has a function type?
 
 {{< highlight haskell >}}
-f :: (Int32 -> Int32) -> Int32 -> Bool
-f h y = (h y) < 10
+f :: (Int16 -> Int32) -> Int16 -> Bool
+f h y = (h y) < (10 :: Int32)
 
-k :: Int32 -> Int32
+k :: Int16 -> Int32
 
-topEntity :: Int32 -> Bool
+topEntity :: Int16 -> Bool
 topEntity x = f k x
 {{< / highlight >}}
 
@@ -46,12 +46,12 @@ How many bits are needed for a port of type `(Int32 -> Int32)`? How would the in
 Clearly this idea of mapping arguments to input ports, and results to output ports, doesn't work when our arguments have a function type. So how does Clash handle this? Well, before converting the expressions to a circuit, uses a process called specialisation to transform the above code to:
 
 {{< highlight haskell >}}
-fK :: Int32 -> Bool
-fK y = (k y) < 10
+fK :: Int16 -> Bool
+fK y = (k y) < (10 :: Int32)
 
-k :: Int32 -> Int32
+k :: Int16 -> Int32
 
-topEntity :: Int32 -> Bool
+topEntity :: Int16 -> Bool
 topEntity x = fK x
 {{< / highlight >}}
 
@@ -70,19 +70,19 @@ Now the following concept is exactly described in the Geometry of Synthesis pape
 So in:
 
 {{< highlight haskell >}}
-f :: (Int32 -> Int32) -> Int32 -> Bool
-f h y = (h y) < 10
+f :: (Int16 -> Int32) -> Int16 -> Bool
+f h y = (h y) < (10 :: Int32)
 
-k :: Int32 -> Int32
+k :: Int16 -> Int32
 
-topEntity :: Int32 -> Bool
+topEntity :: Int16 -> Bool
 topEntity x = f k x
 {{< / highlight >}}
 
 the component for `f` would get: 
 
 * an additional `Int32` input port corresponding to the result of the `h` argument, 
-* and an additional `Int32` output port corresponding to the argument of `h`.
+* and an additional `Int16` output port corresponding to the argument of `h`.
 
 Inside the component for `f` we would then:
 
@@ -101,8 +101,8 @@ _TODO: create a picture making the above more intuiative._
 Now let's say we change our definition of `f` to:
 
 {{< highlight haskell >}}
-f :: (Int32 -> Int32) -> Int32 -> Int -> Bool
-f h x y = (h x + h y) < 10
+f :: (Int16 -> Int32) -> Int16 -> Int16 -> Bool
+f h x y = (h x + h y) < (10 :: Int32)
 {{< / highlight >}}
 
 i.e. apply the function `h` twice to different arguments.
@@ -115,7 +115,7 @@ _TODO: create a picture making the above more intuiative._
 There are two options here:
 
 1. Duplicate the output (and input) ports of the `h` argument so that `x` and `y` can be connected to these outputs seperately; this behaviour basically corresponds to the specialisation transformation Clash applies already.
-2. Use linear arrows
+2. Use linear arrows, change the type signature to `f :: (Int16 -> Int32) -. Int16 -> Int16 -> Bool`, and have the type-checker disallow the duplicate use of `h`.
 
 # Synchronisation and the case for higher-order top-level functions
 You might argue that a first-order top-level function (`topEntity`) is a sensible restriction, after all, it's kind of the "entry point" into your entire circuit (much like `main :: IO ()` in regular Haskell program).

From 98bd1b5a92bdd86276d32da856c4f277b5ed7194 Mon Sep 17 00:00:00 2001
From: Christiaan Baaij <christiaan.baaij@gmail.com>
Date: Mon, 17 Jun 2019 16:56:44 +0200
Subject: [PATCH 17/17] Update 0006-linear-clash.md

---
 content/blog/0006-linear-clash.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/blog/0006-linear-clash.md b/content/blog/0006-linear-clash.md
index 400b2d4..b2fb3fb 100644
--- a/content/blog/0006-linear-clash.md
+++ b/content/blog/0006-linear-clash.md
@@ -10,7 +10,7 @@ toc: false
 mathjax: false
 ---
 
-__TL;DR What does it mean for a function to be used linearly? It means that function's _argument_ will be used linearly. Somewhat surprisingly, in a circuit context it means that the _output port_ of a higher-order argument is only driven by a single source. This means we need linear arrows to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to the circuit.__
+__TL;DR In the context of linear types, what does it mean for a function to be consumed exactly once? It means to apply it to a single argument, and consume its result only once. Somewhat surprisingly, in a circuit context it means that the output port of a higher-order argument is only driven by a single source. This means we need linear types to correctly translate non-duplicable functions, e.g. higher-order arguments corresponding to components peripheral to the circuit.__
 
 I'm writing this post on the train on my way back from an amazing ZuriHac 2019, where I got to meet a lot of new people, many of them really excited about Clash!
 I also got to talk with some about the linear types feature that will hopefully hit GHC HEAD very soon.