Commits

David Barker committed 22f3a6e

Started arrow syntax evaluation section

Comments (0)

Files changed (7)

Dissertation/Dissertation.aux

 \@writefile{toc}{\contentsline {subsection}{\numberline {4.1.1}Automated testing}{27}}
 \@writefile{toc}{\contentsline {subsubsection}{Simple arrows}{28}}
 \@writefile{toc}{\contentsline {subsubsection}{Invertible arrows}{28}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{28}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{29}}
 \@writefile{toc}{\contentsline {section}{\numberline {4.2}Syntax evaluation}{29}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{29}}
-\@writefile{toc}{\contentsline {subsubsection}{Comparison with Haskell}{29}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{29}}
-\@writefile{toc}{\contentsline {subsubsection}{Username two-way binding}{29}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.1}{\ignorespaces The username two-way binding application}}{30}}
-\newlabel{fig:case_study_name}{{4.1}{30}}
-\@writefile{toc}{\contentsline {subsubsection}{List binding from a mock database}{31}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.2}{\ignorespaces The list binding application}}{31}}
-\newlabel{fig:case_study_list}{{4.2}{31}}
-\@writefile{toc}{\contentsline {subsubsection}{Some other demo}{32}}
-\@writefile{toc}{\contentsline {section}{\numberline {4.3}Performance testing}{32}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{32}}
-\@writefile{toc}{\contentsline {subsubsection}{Measuring technique}{32}}
-\@writefile{toc}{\contentsline {subsubsection}{Simple function results}{33}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.3}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{34}}
-\newlabel{fig:simple_function_performance}{{4.3}{34}}
-\@writefile{toc}{\contentsline {subsubsection}{List function results}{34}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.4}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{35}}
-\newlabel{fig:list_function_performance}{{4.4}{35}}
+\@writefile{toc}{\contentsline {subsubsection}{Comparison with Haskell}{30}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{30}}
+\@writefile{toc}{\contentsline {subsubsection}{Username two-way binding}{30}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.1}{\ignorespaces The username two-way binding application}}{31}}
+\newlabel{fig:case_study_name}{{4.1}{31}}
+\@writefile{toc}{\contentsline {subsubsection}{List binding from a mock database}{32}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.2}{\ignorespaces The list binding application}}{32}}
+\newlabel{fig:case_study_list}{{4.2}{32}}
+\@writefile{toc}{\contentsline {subsubsection}{Some other demo}{33}}
+\@writefile{toc}{\contentsline {section}{\numberline {4.3}Performance testing}{33}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{33}}
+\@writefile{toc}{\contentsline {subsubsection}{Measuring technique}{33}}
+\@writefile{toc}{\contentsline {subsubsection}{Simple function results}{34}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.3}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{35}}
+\newlabel{fig:simple_function_performance}{{4.3}{35}}
+\@writefile{toc}{\contentsline {subsubsection}{List function results}{35}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.4}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{36}}
+\newlabel{fig:list_function_performance}{{4.4}{36}}
 \@writefile{toc}{\contentsline {subsubsection}{Overhead due to arrow chaining}{36}}
 \newlabel{sec:arrow_chaining_overhead}{{4.3.1}{36}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.5}{\ignorespaces Execution times of chains of identity functions}}{36}}
-\newlabel{fig:arrow_chaining_overhead}{{4.5}{36}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.2}Binding performance}{36}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {5}Conclusion}{37}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.5}{\ignorespaces Execution times of chains of identity functions}}{37}}
+\newlabel{fig:arrow_chaining_overhead}{{4.5}{37}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.2}Binding performance}{37}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {5}Conclusion}{39}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\@writefile{toc}{\contentsline {section}{\numberline {5.1}Future work}{37}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{37}}
-\newlabel{sec:performance_enhancements}{{5.1.1}{37}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {A}Arrow laws}{39}}
+\@writefile{toc}{\contentsline {section}{\numberline {5.1}Future work}{39}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{39}}
+\newlabel{sec:performance_enhancements}{{5.1.1}{39}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {A}Arrow laws}{41}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\newlabel{sec:arrow_laws}{{A}{39}}
-\@writefile{toc}{\contentsline {section}{\numberline {A.1}Normal arrow laws}{39}}
-\newlabel{sec:simle_arrow_laws}{{A.1}{39}}
-\@writefile{toc}{\contentsline {section}{\numberline {A.2}Invertible arrow laws}{40}}
-\newlabel{sec:invertible_arrow_laws}{{A.2}{40}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {B}WPF integration demo -- code listings}{41}}
+\newlabel{sec:arrow_laws}{{A}{41}}
+\@writefile{toc}{\contentsline {section}{\numberline {A.1}Normal arrow laws}{41}}
+\newlabel{sec:simle_arrow_laws}{{A.1}{41}}
+\@writefile{toc}{\contentsline {section}{\numberline {A.2}Invertible arrow laws}{42}}
+\newlabel{sec:invertible_arrow_laws}{{A.2}{42}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {B}WPF integration demo -- code listings}{43}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\newlabel{sec:wpf_integration_code}{{B}{41}}
-\@writefile{toc}{\contentsline {section}{\numberline {B.1}Creating the bindable source}{41}}
-\@writefile{toc}{\contentsline {section}{\numberline {B.2}The binding arrow}{41}}
-\@writefile{toc}{\contentsline {section}{\numberline {B.3}Doing the binding}{41}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {C}Code samples for case studies}{43}}
+\newlabel{sec:wpf_integration_code}{{B}{43}}
+\@writefile{toc}{\contentsline {section}{\numberline {B.1}Creating the bindable source}{43}}
+\@writefile{toc}{\contentsline {section}{\numberline {B.2}The binding arrow}{43}}
+\@writefile{toc}{\contentsline {section}{\numberline {B.3}Doing the binding}{43}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {C}Code samples for case studies}{45}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\newlabel{sec:case_studies}{{C}{43}}
-\@writefile{toc}{\contentsline {section}{\numberline {C.1}Username two-way binding}{43}}
-\newlabel{sec:case_study_name}{{C.1}{43}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {C.1.1}Creating the bindable data source}{43}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {C.1.2}Creating the functionality for splitting the name}{44}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {C.1.3}Creating the binding}{45}}
-\@writefile{toc}{\contentsline {section}{\numberline {C.2}List binding from a mock database}{47}}
-\newlabel{sec:case_study_list}{{C.2}{47}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {C.2.1}Creating the bindable `database'}{47}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {C.2.2}Filtering and mapping the list}{47}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {C.2.3}Creating the binding}{48}}
-\@writefile{toc}{\contentsline {section}{\numberline {C.3}Some other demo}{49}}
+\newlabel{sec:case_studies}{{C}{45}}
+\@writefile{toc}{\contentsline {section}{\numberline {C.1}Username two-way binding}{45}}
+\newlabel{sec:case_study_name}{{C.1}{45}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.1.1}Creating the bindable data source}{45}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.1.2}Creating the functionality for splitting the name}{46}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.1.3}Creating the binding}{47}}
+\@writefile{toc}{\contentsline {section}{\numberline {C.2}List binding from a mock database}{49}}
+\newlabel{sec:case_study_list}{{C.2}{49}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.2.1}Creating the bindable `database'}{49}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.2.2}Filtering and mapping the list}{49}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {C.2.3}Creating the binding}{50}}
+\@writefile{toc}{\contentsline {section}{\numberline {C.3}Some other demo}{51}}
 \citation{arrow_calculus}
 \citation{hughes_arrows}
 \citation{arrows_robots_frp}

Dissertation/Dissertation.lof

 \contentsline {figure}{\numberline {3.7}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{23}
 \contentsline {figure}{\numberline {3.8}{\ignorespaces WPF integration demo}}{25}
 \addvspace {10\p@ }
-\contentsline {figure}{\numberline {4.1}{\ignorespaces The username two-way binding application}}{30}
-\contentsline {figure}{\numberline {4.2}{\ignorespaces The list binding application}}{31}
-\contentsline {figure}{\numberline {4.3}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{34}
-\contentsline {figure}{\numberline {4.4}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{35}
-\contentsline {figure}{\numberline {4.5}{\ignorespaces Execution times of chains of identity functions}}{36}
+\contentsline {figure}{\numberline {4.1}{\ignorespaces The username two-way binding application}}{31}
+\contentsline {figure}{\numberline {4.2}{\ignorespaces The list binding application}}{32}
+\contentsline {figure}{\numberline {4.3}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{35}
+\contentsline {figure}{\numberline {4.4}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{36}
+\contentsline {figure}{\numberline {4.5}{\ignorespaces Execution times of chains of identity functions}}{37}
 \addvspace {10\p@ }
 \addvspace {10\p@ }
 \addvspace {10\p@ }

Dissertation/Dissertation.log

-This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  29 APR 2013 13:55
+This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  29 APR 2013 15:07
 entering extended mode
 **Dissertation.tex
 
 Chapter 4.
 [27
 
-] [28] <fig/CaseStudyNameBinding.png, id=211, 283.0575pt x 210.7875pt>
+] [28] [29] <fig/CaseStudyNameBinding.png, id=214, 283.0575pt x 210.7875pt>
 File: fig/CaseStudyNameBinding.png Graphic file (type png)
 
 <use fig/CaseStudyNameBinding.png>
-Package pdftex.def Info: fig/CaseStudyNameBinding.png used on input line 622.
+Package pdftex.def Info: fig/CaseStudyNameBinding.png used on input line 642.
 (pdftex.def)             Requested size: 283.0568pt x 210.78699pt.
- [29] [30 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBindin
+ [30] [31 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBindin
 g/Dissertation/fig/CaseStudyNameBinding.png>] <fig/CaseStudyListBinding.png, id
-=218, 596.2275pt x 423.5825pt>
+=221, 596.2275pt x 423.5825pt>
 File: fig/CaseStudyListBinding.png Graphic file (type png)
 
 <use fig/CaseStudyListBinding.png>
-Package pdftex.def Info: fig/CaseStudyListBinding.png used on input line 643.
+Package pdftex.def Info: fig/CaseStudyListBinding.png used on input line 663.
 (pdftex.def)             Requested size: 411.93877pt x 292.66003pt.
- [31 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+ [32 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/CaseStudyListBinding.png>]
-[32] [33]
-<fig/SimpleFunctionPerformanceChart.pdf, id=229, 496.44887pt x 258.75552pt>
+[33] [34]
+<fig/SimpleFunctionPerformanceChart.pdf, id=232, 496.44887pt x 258.75552pt>
 File: fig/SimpleFunctionPerformanceChart.pdf Graphic file (type pdf)
 
 <use fig/SimpleFunctionPerformanceChart.pdf>
 Package pdftex.def Info: fig/SimpleFunctionPerformanceChart.pdf used on input l
-ine 701.
+ine 721.
 (pdftex.def)             Requested size: 411.93877pt x 214.71175pt.
- [34 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+ [35 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/SimpleFunctionPerformanceChart.pdf>]
-<fig/ListFunctionPerformanceChart.pdf, id=303, 496.4172pt x 244.72725pt>
+<fig/ListFunctionPerformanceChart.pdf, id=306, 496.4172pt x 244.72725pt>
 File: fig/ListFunctionPerformanceChart.pdf Graphic file (type pdf)
 
 <use fig/ListFunctionPerformanceChart.pdf>
 Package pdftex.def Info: fig/ListFunctionPerformanceChart.pdf used on input lin
-e 720.
+e 740.
 (pdftex.def)             Requested size: 411.93877pt x 203.08247pt.
- [35 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+ [36 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/ListFunctionPerformanceChart.pdf>] <fig/IdentityChains.pdf, id=37
-1, 496.51498pt x 216.57913pt>
+4, 496.51498pt x 216.57913pt>
 File: fig/IdentityChains.pdf Graphic file (type pdf)
 
 <use fig/IdentityChains.pdf>
-Package pdftex.def Info: fig/IdentityChains.pdf used on input line 734.
+Package pdftex.def Info: fig/IdentityChains.pdf used on input line 754.
 (pdftex.def)             Requested size: 411.93877pt x 179.69122pt.
- [36 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
-sertation/fig/IdentityChains.pdf>]
-Chapter 5.
-[37
+ [37 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+sertation/fig/IdentityChains.pdf>] [38
 
+]
+Chapter 5.
+[39
 
-] [38
+] [40
 
 ]
 Appendix A.
-[39
+[41
 
-] [40]
+] [42]
 Appendix B.
-[41
+[43
 
 
-] [42
+] [44
 
 ]
 Appendix C.
 \pc@column@2=\box30
 \pc@column@width@2=\dimen120
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 924.
+ne 944.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 924.
-[43
+ne 944.
+[45
 
 ]
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 979.
+ne 999.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 979.
- [44]
+ne 999.
+ [46]
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 1024.
+ne 1044.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 1024.
- [45] [46]
+ne 1044.
+ [47] [48]
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 1066.
+ne 1086.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 1066.
- [47
+ne 1086.
+ [49
 
 ]
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 1108.
+ne 1128.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 1108.
- [48] [49
+ne 1128.
+ [50] [51
 
-] [50
+] [52
 
 ]
 ("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
 a-tion.
  []
 
-[51
+[53
 
-]) [52]
+]) [54]
 ("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
 ation\Dissertation.aux") ) 
 Here is how much of TeX's memory you used:
- 2968 strings out of 494045
- 43643 string characters out of 3148387
+ 2973 strings out of 494045
+ 43745 string characters out of 3148387
  271622 words of memory out of 3000000
- 6238 multiletter control sequences out of 15000+200000
+ 6243 multiletter control sequences out of 15000+200000
  12938 words of font info for 46 fonts, out of 3000000 for 9000
  715 hyphenation exceptions out of 8191
  27i,8n,40p,1132b,1520s stack positions out of 5000i,500n,10000p,200000b,50000s
 ogram Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt10.pfb><C:/Program Fi
 les/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt12.pfb><C:/Program Files/MiKT
 eX 2.9/fonts/type1/public/amsfonts/cm/cmtt8.pfb>
-Output written on Dissertation.pdf (62 pages, 558058 bytes).
+Output written on Dissertation.pdf (64 pages, 562169 bytes).
 PDF statistics:
- 619 PDF objects out of 1000 (max. 8388607)
+ 625 PDF objects out of 1000 (max. 8388607)
  0 named destinations out of 1000 (max. 500000)
  61 words of extra memory for PDF output out of 10000 (max. 10000000)
 

Dissertation/Dissertation.pdf

Binary file modified.

Dissertation/Dissertation.synctex.gz

Binary file modified.

Dissertation/Dissertation.tex

 
 \subsubsection{Invertible arrows}
 
-Invertible arrow laws are listed in Appendix \ref{sec:invertible_arrow_laws}, again with their C$\sharp$ equivalents. These were slightly more complicated to test than simple arrows as the laws have to hold for inverses as well.
+Invertible arrow laws are listed in Appendix \ref{sec:invertible_arrow_laws}, again with their C$\sharp$ equivalents. These were slightly more complicated to test than simple arrows as the laws have to hold for inverses as well. They also required random arrows with inverses provided as well. However, aside from being slightly longer to write the laws were generally fairly simple to test. As a small example, the test for double inversion is given below:
 
-[TBContinued]
+\begin{lstlisting}
+public static bool TestDoubleInversion()
+{
+  var arr1 = Op.Arr((int x) => x * 7, (int y) => y / 7);
+  var arr2 = arr1.Invert().Invert();
+
+  return ArrowTestUtils.AssertInvertibleArrowsGiveSameOutput(arr1, arr2);
+}
+\end{lstlisting}
+
+Including minor variations from different sources, 24 different arrow laws were tested in total, and all passed on large quantities of random input data. This gives a reasonably good indication that the arrow implementation is correct.
 
 \subsection{Correctness proof by decomposing into lambda calculus}
 
 
 \subsection{Arrow syntax}
 
-Show major operators - arrow construction (niceish), arrow combination (niceish), First operator (not ideal - perhaps show all the differently imperfect ways of applying it); discuss the lack of type parameters despite the mad type-ing skillz going on (woo mad type inference skills!).
+Syntax is a difficult thing to give an objective evaluation of without extensive user trials and a variety of different opinions, and there are many conflicting metrics which could be use to judge its quality. However, the way this project was originally set out allows for a certain degree of objective syntax evaluation: brevity was a key goal, along with removing the need for type parameters and providing syntax for all the standard arrow operators. This section will therefore evaluate the syntax of the arrow implementation in terms of these key features, and in doing so highlight how well the project's original goals were met. A comparison with Haskell's syntax is also provided, taking into account the limitations inherent in C$\sharp$ for fairness.
+
+One of the main syntactic achievements of the project was finding ways of writing all the arrow combinators such that under normal circumstances the user need never provide explicit type parameters. Given a typed lambda expression, for instance \texttt{(int x) => x + 1}, arrow construction is done with \texttt{Op.Arr((int x) => x + 1)}. From there, the type of this arrow is used to infer the types required for all the combinators -- composition, for example, is simply \texttt{arrow.Combine(otherArrow)}.
+
+Less successful was the \texttt{First} operator. As outlined in Section \ref{sec:simple_arrow_challenges}, many approaches were attempted for this, but all turned out slightly messy. The current preferred approach is \texttt{arrow.First(default(T))}, where \texttt{T} is the type parameter which cannot be inferred. However, \texttt{arrow.First<T>()} is arguably slightly better as it is clearer what it does (passing \texttt{default(T)} definitely qualifies as a `hack'), and so it is used in the arrow law listings of Appendix \ref{sec:arrow_laws} for clarity. The main problems are that it takes an extra type parameter and relies heavily on reflection, leading to slower execution.
+
+Extension methods -- handy. However, Op preceding all non-extension methods is a faff, but this is because C$\sharp$ doesn't allow methods to be used without a containing class
 
 \subsubsection{Comparison with Haskell}
 
 Firstly, mention difference in specifying lambdas and shizz (C sharp stunted from the start). From there, show how C sharp arrows create arrows from them (need types specified somewhere is an issue (no type inference like Haskell gets), C sharp also has a strict function calling syntax which doesn't allow Haskell's pretty currying syntax). Go on to give a few examples of complicated-ish arrows expressed in both? Also, maaaybe mention the shiny new syntax Haskell has for arrows, but the C sharp implementation can't really battle that so it's not worth going into much detail about.
 
+%While the syntax is reasonably concise in
+
 \subsection{Binding syntax}
 
 To evaluate how concise and readable the binding syntax is, a few case study applications were written using both normal WPF binding and arrow-based binding. The key code snippets from the resulting programs are listed in Appendix \ref{sec:case_studies}, and this section explores how the samples differ and how successful the attempt to simplify binding syntax and reduce boilerplate code was.

Dissertation/Dissertation.toc

 \contentsline {subsection}{\numberline {4.1.1}Automated testing}{27}
 \contentsline {subsubsection}{Simple arrows}{28}
 \contentsline {subsubsection}{Invertible arrows}{28}
-\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{28}
+\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{29}
 \contentsline {section}{\numberline {4.2}Syntax evaluation}{29}
 \contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{29}
-\contentsline {subsubsection}{Comparison with Haskell}{29}
-\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{29}
-\contentsline {subsubsection}{Username two-way binding}{29}
-\contentsline {subsubsection}{List binding from a mock database}{31}
-\contentsline {subsubsection}{Some other demo}{32}
-\contentsline {section}{\numberline {4.3}Performance testing}{32}
-\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{32}
-\contentsline {subsubsection}{Measuring technique}{32}
-\contentsline {subsubsection}{Simple function results}{33}
-\contentsline {subsubsection}{List function results}{34}
+\contentsline {subsubsection}{Comparison with Haskell}{30}
+\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{30}
+\contentsline {subsubsection}{Username two-way binding}{30}
+\contentsline {subsubsection}{List binding from a mock database}{32}
+\contentsline {subsubsection}{Some other demo}{33}
+\contentsline {section}{\numberline {4.3}Performance testing}{33}
+\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{33}
+\contentsline {subsubsection}{Measuring technique}{33}
+\contentsline {subsubsection}{Simple function results}{34}
+\contentsline {subsubsection}{List function results}{35}
 \contentsline {subsubsection}{Overhead due to arrow chaining}{36}
-\contentsline {subsection}{\numberline {4.3.2}Binding performance}{36}
-\contentsline {chapter}{\numberline {5}Conclusion}{37}
-\contentsline {section}{\numberline {5.1}Future work}{37}
-\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{37}
-\contentsline {chapter}{\numberline {A}Arrow laws}{39}
-\contentsline {section}{\numberline {A.1}Normal arrow laws}{39}
-\contentsline {section}{\numberline {A.2}Invertible arrow laws}{40}
-\contentsline {chapter}{\numberline {B}WPF integration demo -- code listings}{41}
-\contentsline {section}{\numberline {B.1}Creating the bindable source}{41}
-\contentsline {section}{\numberline {B.2}The binding arrow}{41}
-\contentsline {section}{\numberline {B.3}Doing the binding}{41}
-\contentsline {chapter}{\numberline {C}Code samples for case studies}{43}
-\contentsline {section}{\numberline {C.1}Username two-way binding}{43}
-\contentsline {subsection}{\numberline {C.1.1}Creating the bindable data source}{43}
-\contentsline {subsection}{\numberline {C.1.2}Creating the functionality for splitting the name}{44}
-\contentsline {subsection}{\numberline {C.1.3}Creating the binding}{45}
-\contentsline {section}{\numberline {C.2}List binding from a mock database}{47}
-\contentsline {subsection}{\numberline {C.2.1}Creating the bindable `database'}{47}
-\contentsline {subsection}{\numberline {C.2.2}Filtering and mapping the list}{47}
-\contentsline {subsection}{\numberline {C.2.3}Creating the binding}{48}
-\contentsline {section}{\numberline {C.3}Some other demo}{49}
+\contentsline {subsection}{\numberline {4.3.2}Binding performance}{37}
+\contentsline {chapter}{\numberline {5}Conclusion}{39}
+\contentsline {section}{\numberline {5.1}Future work}{39}
+\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{39}
+\contentsline {chapter}{\numberline {A}Arrow laws}{41}
+\contentsline {section}{\numberline {A.1}Normal arrow laws}{41}
+\contentsline {section}{\numberline {A.2}Invertible arrow laws}{42}
+\contentsline {chapter}{\numberline {B}WPF integration demo -- code listings}{43}
+\contentsline {section}{\numberline {B.1}Creating the bindable source}{43}
+\contentsline {section}{\numberline {B.2}The binding arrow}{43}
+\contentsline {section}{\numberline {B.3}Doing the binding}{43}
+\contentsline {chapter}{\numberline {C}Code samples for case studies}{45}
+\contentsline {section}{\numberline {C.1}Username two-way binding}{45}
+\contentsline {subsection}{\numberline {C.1.1}Creating the bindable data source}{45}
+\contentsline {subsection}{\numberline {C.1.2}Creating the functionality for splitting the name}{46}
+\contentsline {subsection}{\numberline {C.1.3}Creating the binding}{47}
+\contentsline {section}{\numberline {C.2}List binding from a mock database}{49}
+\contentsline {subsection}{\numberline {C.2.1}Creating the bindable `database'}{49}
+\contentsline {subsection}{\numberline {C.2.2}Filtering and mapping the list}{49}
+\contentsline {subsection}{\numberline {C.2.3}Creating the binding}{50}
+\contentsline {section}{\numberline {C.3}Some other demo}{51}