status/oct13.md

@@ -31,6 +31,25 @@ The GHC 7.8 release is in its final stages, and will be released in late Novembe
 
 - **New and improved I/O manager** - Earlier this year, Andreas Voellmy and Kazu Yamamoto worked on a host of improvements to our I/O manager, making it scale significantly better on multicore machines. Since then, it's seen some other performance tweaks, and many bugfixes. As a result, the new I/O manager should scale linearly up to about 40 cores. Andreas reports their McNettle Software-defined-network (SDN) implementation can now achieve over *twenty million connections per second*, making it the fastest SDN implementation around - an incredible feat!
 
+- **Type Holes** - Thijs Alkemade and Simon PJ got an implementation of `TypeHoles` in GHC, meaning it's possible to tell GHC there is a 'hole' in a program, and have the compiler spit out an error stating what types are in scope. As a trivial example
+
+  ```wiki
+  Prelude> :set -XTypeHoles 
+  Prelude> let f :: a -> a; f x = _
+
+  <interactive>:6:24:
+      Found hole ‛_’ with type: a
+      Where: ‛a’ is a rigid type variable bound by
+                 the type signature for f :: a -> a at <interactive>:6:10
+      Relevant bindings include
+        x :: a (bound at <interactive>:6:20)
+        f :: a -> a (bound at <interactive>:6:18)
+      In the expression: _
+      In an equation for ‛f’: f x = _
+  ```
+
+  GHC now tells us that the term `f` has a hole of type `a`, and there is a term `x :: a` in scope. So the definition is clear: `f x = x`. Holes are originally a concept borrowed from [ Agda](http://wiki.portal.chalmers.se/agda/pmwiki.php), and we hope they will be useful to Haskell programmers too!
+
 - **New Template Haskell** - Geoffrey Mainland implemented support for New Template Haskell, fixing a lot of long-standing bugs with the TH implementation, while making it significantly more expressive, including support for typed quotes, pattern splices and more. This allows us to write for example a typed, staged power function. For details and examples, you can see Geoff's blog \[NewTH1\] and the GHC wiki pages describing the design \[NewTH2\].
 
 - **Newtype coercions**.  Joachim Breitner spent time earlier this year implementing a new, fancy **Coercible** design in GHC, which helps eliminate the cases in which newtypes are 'not free'. This occurs for example, when we say something like `newtype Age = MkAge Int` and then `map MkAge [0..10]` - while `newtype` is supposed to be free, this particular example has a runtime cost!
@@ -85,7 +104,7 @@ After the 7.8 release, there are some improvements scheduled we plan on integrat
 
 - **Overloaded record fields ** - Adam Gundry implemented the overloaded records field proposal as part of the Haskell.org 2013 GSoC. This work will make it possible to not only have overloaded record field names, but also enable a wealth of other nice features, like polymorphic update/lookup, and automatically turning record fields into lens. More detail can be found on the GHC wiki \[ORF\].
 
-- **Pattern synonyms** - Gergö Érdi worked on an implementation of pattern synonyms for GHC, which will finally give us the power to abstract over patterns and give them names. While the design is not final (see the wiki for details\[PS\]), the results look promising, and hopefully fix a long-standing 'abstraction hole' in the term language for Haskell.
+- **Pattern synonyms** - Gergö Érdi worked on an implementation of pattern synonyms for GHC, which will finally give us the power to abstract over patterns and give them names. While the design is not final (see the wiki for details\[PS\]), the results look promising, and will hopefully fix a long-standing 'abstraction hole' in the term language for Haskell.
 
 - **Explicit Type Application** - Stephanie Weirich, Richard Eisenberg and Hamidhasan Ahmed have been working on adding explicit type applications to GHC. This allows the programmer to specify the *types* that should be instantiated for arguments to a function application, where normally they would be inferred. While this capability already exists in GHC's internal language, System FC -- indeed, every FC-pro program has function application with explicitly applied types -- it has not been available in Haskell itself. While a lot of the syntax and design is not quite final, there are some details about the design available on the wiki \[TA\].