1. David Barker
  2. C# Arrows

Commits

David Barker  committed c4286c5

Started writing the overview bit for the binding implementation

  • Participants
  • Parent commits ee87440
  • Branches master

Comments (0)

Files changed (7)

File Dissertation/Dissertation.aux

View file
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.2.1}Overview}{9}}
 \newlabel{sec:arrows_overview}{{3.2.1}{9}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.2.2}Simple arrows}{10}}
+\newlabel{sec:simple_arrow_implementation}{{3.2.2}{10}}
 \@writefile{lof}{\contentsline {figure}{\numberline {3.1}{\ignorespaces The Arr operator}}{10}}
 \newlabel{fig:arr_operator}{{3.1}{10}}
 \@writefile{lof}{\contentsline {figure}{\numberline {3.2}{\ignorespaces The Combine operator}}{11}}
 \@writefile{toc}{\contentsline {section}{\numberline {3.3}Data binding}{16}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.3.1}Overall architecture}{16}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {3.3.2}Creating bindable sources and destinations}{17}}
-\newlabel{lst:bindable_source_class}{{3.1}{17}}
-\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.1}Creating a bindable source class}{17}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.3}Creating bindings}{18}}
+\newlabel{lst:bindable_source_class}{{3.1}{18}}
+\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.1}Creating a bindable source class}{18}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.3}Creating bindings}{19}}
 \@writefile{toc}{\contentsline {subsubsection}{Syntax and usage}{19}}
-\newlabel{lst:creating_simple_binding}{{3.2}{19}}
-\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.2}Creating a binding between two properties}{19}}
-\@writefile{toc}{\contentsline {subsubsection}{Two-way binding}{19}}
-\@writefile{toc}{\contentsline {subsubsection}{Cycle and conflict detection}{19}}
-\newlabel{lst:cycle_conflict_pseudocode}{{3.3}{20}}
-\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.3}Pseudocode for cycle and conflict detection}{20}}
+\newlabel{lst:creating_simple_binding}{{3.2}{20}}
+\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.2}Creating a binding between two properties}{20}}
+\@writefile{toc}{\contentsline {subsubsection}{Two-way binding}{20}}
+\@writefile{toc}{\contentsline {subsubsection}{Cycle and conflict detection}{20}}
+\newlabel{lst:cycle_conflict_pseudocode}{{3.3}{21}}
+\@writefile{lol}{\contentsline {lstlisting}{\numberline {3.3}Pseudocode for cycle and conflict detection}{21}}
 \@writefile{toc}{\contentsline {subsubsection}{Many-to-many bindings}{21}}
 \@writefile{lof}{\contentsline {figure}{\numberline {3.5}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{22}}
 \newlabel{fig:argument_marshalling}{{3.5}{22}}
 \@writefile{toc}{\contentsline {subsubsection}{Problems encountered}{22}}
 \@writefile{toc}{\contentsline {paragraph}{Type safety}{22}}
-\@writefile{toc}{\contentsline {paragraph}{Binding to lists}{22}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{22}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {4}Evaluation}{23}}
+\@writefile{toc}{\contentsline {paragraph}{Binding to lists}{23}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{23}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {4}Evaluation}{25}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\@writefile{toc}{\contentsline {section}{\numberline {4.1}Correctness of arrow implementations}{23}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.1}Automated testing}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{Simple arrows}{24}}
-\@writefile{toc}{\contentsline {subsubsection}{Invertible arrows}{24}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{24}}
-\@writefile{toc}{\contentsline {section}{\numberline {4.2}Syntax evaluation}{25}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{25}}
-\@writefile{toc}{\contentsline {subsubsection}{Comparison with Haskell}{25}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{25}}
-\@writefile{toc}{\contentsline {subsubsection}{Username two-way binding}{25}}
-\@writefile{toc}{\contentsline {subsubsection}{List binding from a mock database}{25}}
-\@writefile{toc}{\contentsline {subsubsection}{Some other demo}{25}}
-\@writefile{toc}{\contentsline {section}{\numberline {4.3}Performance testing}{25}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{25}}
-\@writefile{toc}{\contentsline {subsubsection}{Measuring technique}{26}}
-\@writefile{toc}{\contentsline {subsubsection}{Simple function results}{26}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.1}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{27}}
-\newlabel{fig:simple_function_performance}{{4.1}{27}}
-\@writefile{toc}{\contentsline {subsubsection}{List function results}{27}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{28}}
-\newlabel{fig:list_function_performance}{{4.2}{28}}
-\@writefile{toc}{\contentsline {subsubsection}{Overhead due to arrow chaining}{28}}
-\newlabel{sec:arrow_chaining_overhead}{{4.3.1}{28}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.2}Binding performance}{28}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.3}{\ignorespaces Execution times of chains of identity functions}}{29}}
-\newlabel{fig:arrow_chaining_overhead}{{4.3}{29}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {5}Conclusion}{31}}
+\@writefile{toc}{\contentsline {section}{\numberline {4.1}Correctness of arrow implementations}{25}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.1}Automated testing}{25}}
+\@writefile{toc}{\contentsline {subsubsection}{Simple arrows}{26}}
+\@writefile{toc}{\contentsline {subsubsection}{Invertible arrows}{26}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{26}}
+\@writefile{toc}{\contentsline {section}{\numberline {4.2}Syntax evaluation}{27}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{27}}
+\@writefile{toc}{\contentsline {subsubsection}{Comparison with Haskell}{27}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{27}}
+\@writefile{toc}{\contentsline {subsubsection}{Username two-way binding}{27}}
+\@writefile{toc}{\contentsline {subsubsection}{List binding from a mock database}{27}}
+\@writefile{toc}{\contentsline {subsubsection}{Some other demo}{27}}
+\@writefile{toc}{\contentsline {section}{\numberline {4.3}Performance testing}{27}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{27}}
+\@writefile{toc}{\contentsline {subsubsection}{Measuring technique}{28}}
+\@writefile{toc}{\contentsline {subsubsection}{Simple function results}{28}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.1}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{29}}
+\newlabel{fig:simple_function_performance}{{4.1}{29}}
+\@writefile{toc}{\contentsline {subsubsection}{List function results}{29}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{30}}
+\newlabel{fig:list_function_performance}{{4.2}{30}}
+\@writefile{toc}{\contentsline {subsubsection}{Overhead due to arrow chaining}{30}}
+\newlabel{sec:arrow_chaining_overhead}{{4.3.1}{30}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.2}Binding performance}{30}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.3}{\ignorespaces Execution times of chains of identity functions}}{31}}
+\newlabel{fig:arrow_chaining_overhead}{{4.3}{31}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {5}Conclusion}{33}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\@writefile{toc}{\contentsline {section}{\numberline {5.1}Future work}{31}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{31}}
-\newlabel{sec:performance_enhancements}{{5.1.1}{31}}
-\@writefile{toc}{\contentsline {chapter}{\numberline {A}Arrow laws}{33}}
+\@writefile{toc}{\contentsline {section}{\numberline {5.1}Future work}{33}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{33}}
+\newlabel{sec:performance_enhancements}{{5.1.1}{33}}
+\@writefile{toc}{\contentsline {chapter}{\numberline {A}Arrow laws}{35}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
-\newlabel{sec:arrow_laws}{{A}{33}}
-\@writefile{toc}{\contentsline {section}{\numberline {A.1}Normal arrow laws}{33}}
-\newlabel{sec:simle_arrow_laws}{{A.1}{33}}
-\@writefile{toc}{\contentsline {section}{\numberline {A.2}Invertible arrow laws}{34}}
-\newlabel{sec:invertible_arrow_laws}{{A.2}{34}}
+\newlabel{sec:arrow_laws}{{A}{35}}
+\@writefile{toc}{\contentsline {section}{\numberline {A.1}Normal arrow laws}{35}}
+\newlabel{sec:simle_arrow_laws}{{A.1}{35}}
+\@writefile{toc}{\contentsline {section}{\numberline {A.2}Invertible arrow laws}{36}}
+\newlabel{sec:invertible_arrow_laws}{{A.2}{36}}

File Dissertation/Dissertation.lof

View file
 \contentsline {figure}{\numberline {3.4}{\ignorespaces The And operator}}{12}
 \contentsline {figure}{\numberline {3.5}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{22}
 \addvspace {10\p@ }
-\contentsline {figure}{\numberline {4.1}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{27}
-\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{28}
-\contentsline {figure}{\numberline {4.3}{\ignorespaces Execution times of chains of identity functions}}{29}
+\contentsline {figure}{\numberline {4.1}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{29}
+\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{30}
+\contentsline {figure}{\numberline {4.3}{\ignorespaces Execution times of chains of identity functions}}{31}
 \addvspace {10\p@ }
 \addvspace {10\p@ }

File Dissertation/Dissertation.log

View file
-This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  29 MAR 2013 18:40
+This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  2 APR 2013 02:19
 entering extended mode
 **Dissertation.tex
 
 LaTeX Font Info:    Font shape `OMS/cmr/m/n' in size <12> not available
 (Font)              Font shape `OMS/cmsy/m/n' tried instead on input line 371.
  [15] [16] [17]
-[18]
+[18] [19]
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
- [19] [20]
-<fig/ArgumentMarshalling.pdf, id=148, 511.24123pt x 147.77261pt>
+ [20] [21]
+<fig/ArgumentMarshalling.pdf, id=152, 511.24123pt x 147.77261pt>
 File: fig/ArgumentMarshalling.pdf Graphic file (type pdf)
 
 <use fig/ArgumentMarshalling.pdf>
-Package pdftex.def Info: fig/ArgumentMarshalling.pdf used on input line 482.
+Package pdftex.def Info: fig/ArgumentMarshalling.pdf used on input line 484.
 (pdftex.def)             Requested size: 411.93877pt x 119.07281pt.
- [21]
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
  [22 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/ArgumentMarshalling.pdf>]
-Chapter 4.
-[23
+[23] [24
 
+]
+Chapter 4.
+[25
 
-] [24] [25] [26]
-<fig/SimpleFunctionPerformanceChart.pdf, id=177, 496.44887pt x 258.75552pt>
+] [26] [27] [28]
+<fig/SimpleFunctionPerformanceChart.pdf, id=184, 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 620.
+ine 622.
 (pdftex.def)             Requested size: 411.93877pt x 214.71175pt.
 
-<fig/ListFunctionPerformanceChart.pdf, id=178, 496.4172pt x 244.72725pt>
+<fig/ListFunctionPerformanceChart.pdf, id=185, 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 631.
+e 633.
 (pdftex.def)             Requested size: 411.93877pt x 203.08247pt.
- [27 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+ [29 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/SimpleFunctionPerformanceChart.pdf>] <fig/IdentityChains.pdf, id=
-253, 496.51498pt x 216.57913pt>
+259, 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 645.
+Package pdftex.def Info: fig/IdentityChains.pdf used on input line 647.
 (pdftex.def)             Requested size: 411.93877pt x 179.69122pt.
- [28 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+ [30 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
 sertation/fig/ListFunctionPerformanceChart.pdf>]
-[29 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Diss
-ertation/fig/IdentityChains.pdf>] [30
+[31 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Diss
+ertation/fig/IdentityChains.pdf>] [32
 
 ]
 Chapter 5.
-[31
+[33
 
-] [32
+] [34
 
 ]
 Appendix A.
-[33
+[35
 
-] [34]
+] [36]
 ("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
 ation\Dissertation.aux") ) 
 Here is how much of TeX's memory you used:
- 2767 strings out of 494045
- 39825 string characters out of 3148387
- 185503 words of memory out of 3000000
- 6054 multiletter control sequences out of 15000+200000
+ 2768 strings out of 494045
+ 39858 string characters out of 3148387
+ 185571 words of memory out of 3000000
+ 6055 multiletter control sequences out of 15000+200000
  12602 words of font info for 44 fonts, out of 3000000 for 9000
  715 hyphenation exceptions out of 8191
  27i,8n,42p,1132b,1509s stack positions out of 5000i,500n,10000p,200000b,50000s
 nts/cm/cmsy10.pfb><C:/Program Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/c
 mti12.pfb><C:/Program Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt10.pf
 b><C:/Program Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt12.pfb>
-Output written on Dissertation.pdf (44 pages, 399920 bytes).
+Output written on Dissertation.pdf (46 pages, 402348 bytes).
 PDF statistics:
- 524 PDF objects out of 1000 (max. 8388607)
+ 530 PDF objects out of 1000 (max. 8388607)
  0 named destinations out of 1000 (max. 500000)
  41 words of extra memory for PDF output out of 10000 (max. 10000000)
 

File Dissertation/Dissertation.pdf

Binary file modified.

File Dissertation/Dissertation.synctex.gz

Binary file modified.

File Dissertation/Dissertation.tex

View file
 
 Arrows were introduced by Hughes as a generalisation of \texttt{monads}. A monad takes the form \texttt{m a}, representing some computation which will give a result of type \texttt{a}. These are often useful in representing sequences of operations and those which involve side-effects. The basic monad type interface provides an identity function, which gives a monad returning whatever its input was, and a means of chaining monadic functions together. One way of viewing these is as a way of letting the programmer chain together functions in a way controlled by the monad -- for instance, the monad could be written to ensure that some form of global state is passed through along with the function results, or it could be used to handle error conditions without the programmer needing to write extra code for this. In all cases it is essentially handling some side-effect or background operation for the programmer, allowing them to chain various operations together without explicitly handling the side-effects.
 
-Arrows represent a generalisation of monads, in the sense that any monad can be equivalently implemented as an arrow. However, an arrow is of the form \texttt{a b c}, taking an input of type \texttt{b} and transforming it into an output of type \texttt{c}.
+Arrows represent a generalisation of monads, in the sense that any monad can be equivalently implemented as an arrow. However, an arrow is of the form \texttt{arrow b c}, taking an input of type \texttt{b} and transforming it into an output of type \texttt{c}. The basic operators are similar: an \texttt{arr} operator takes a function as an argument and returns the arrow representing that function, and the \texttt{>>>} operator chains two arrows together such that the output of the first is passed through the second. Further to these, the \texttt{first} operator takes an \texttt{arrow b c} and returns an \texttt{arrow (b, d) (c, d)} -- an arrow taking a pair and applying the original arrow only to the first element of the pair. With these basic operators, a number of more complex standard operators can be built up. These are discussed in Section \ref{sec:simple_arrow_implementation} on the implementation of arrows.
 
 Arrows were selected for this project as the semantic nature of an \texttt{arrow a b} is simply a transformation from an input of type \texttt{a} to an output of type \texttt{b}, an interpretation which works well as a generalised model of the nature of data binding.
 
 
 [Maybe mention arrow intercompatibility?]
 
-\subsection{Simple arrows}
+\subsection{Simple arrows} \label{sec:simple_arrow_implementation}
 
 The first objective in implementing arrows was to get the simple function-based arrow working, as all the others derive from this. As mentioned earlier, it was implemented using the C$\sharp$ \texttt{Func<A, B>} class to hold its function. An \texttt{Invoke} method is then exposed for using the arrow.
 
 
 \subsection{Overall architecture}
 
-Use diagrams and stuff to explain it.
+The basis for the data binding system is a publish/subscribe network, where bound values publish events when they are updated and bindings update on receiving these events. A couple of alternatives were considered for this: the first idea was to have binding sources hold a reference to their target and a copy of the arrow associated with the binding, allowing them to simply update the referenced value via the arrow when needed. However, C$\sharp$ lacks the ability to hold references as member variables in this way. The simple approach of simply periodically polling all bound variables to check for updates was also considered, but this was clearly no good: polling is system-intensive and wasteful with many bindings using the same source, a binding target's value would potentially be 'invalid' between polling updates, and the bindings manager would need to store a copy of every bound variable.
+
+Conveniently, C$\sharp$ provides simple syntax for event-based programming. Events can be created for a class and thrown with a method call, and other objects can subscribe and unsubscribe simply by adding or removing their handler methods from the event. The clearest approach was therefore to attach events to bindable objects and have them trigger whenever a bound variable is updated. The bindings manager, when creating a binding, need only tell the binding to subscribe to the source object's event and the rest is simple. [Continue]
 
 \subsection{Creating bindable sources and destinations}
 

File Dissertation/Dissertation.toc

View file
 \contentsline {section}{\numberline {3.3}Data binding}{16}
 \contentsline {subsection}{\numberline {3.3.1}Overall architecture}{16}
 \contentsline {subsection}{\numberline {3.3.2}Creating bindable sources and destinations}{17}
-\contentsline {subsection}{\numberline {3.3.3}Creating bindings}{18}
+\contentsline {subsection}{\numberline {3.3.3}Creating bindings}{19}
 \contentsline {subsubsection}{Syntax and usage}{19}
-\contentsline {subsubsection}{Two-way binding}{19}
-\contentsline {subsubsection}{Cycle and conflict detection}{19}
+\contentsline {subsubsection}{Two-way binding}{20}
+\contentsline {subsubsection}{Cycle and conflict detection}{20}
 \contentsline {subsubsection}{Many-to-many bindings}{21}
 \contentsline {subsubsection}{Problems encountered}{22}
 \contentsline {paragraph}{Type safety}{22}
-\contentsline {paragraph}{Binding to lists}{22}
-\contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{22}
-\contentsline {chapter}{\numberline {4}Evaluation}{23}
-\contentsline {section}{\numberline {4.1}Correctness of arrow implementations}{23}
-\contentsline {subsection}{\numberline {4.1.1}Automated testing}{23}
-\contentsline {subsubsection}{Simple arrows}{24}
-\contentsline {subsubsection}{Invertible arrows}{24}
-\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{24}
-\contentsline {section}{\numberline {4.2}Syntax evaluation}{25}
-\contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{25}
-\contentsline {subsubsection}{Comparison with Haskell}{25}
-\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{25}
-\contentsline {subsubsection}{Username two-way binding}{25}
-\contentsline {subsubsection}{List binding from a mock database}{25}
-\contentsline {subsubsection}{Some other demo}{25}
-\contentsline {section}{\numberline {4.3}Performance testing}{25}
-\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{25}
-\contentsline {subsubsection}{Measuring technique}{26}
-\contentsline {subsubsection}{Simple function results}{26}
-\contentsline {subsubsection}{List function results}{27}
-\contentsline {subsubsection}{Overhead due to arrow chaining}{28}
-\contentsline {subsection}{\numberline {4.3.2}Binding performance}{28}
-\contentsline {chapter}{\numberline {5}Conclusion}{31}
-\contentsline {section}{\numberline {5.1}Future work}{31}
-\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{31}
-\contentsline {chapter}{\numberline {A}Arrow laws}{33}
-\contentsline {section}{\numberline {A.1}Normal arrow laws}{33}
-\contentsline {section}{\numberline {A.2}Invertible arrow laws}{34}
+\contentsline {paragraph}{Binding to lists}{23}
+\contentsline {subsection}{\numberline {3.3.4}Integration work with WPF}{23}
+\contentsline {chapter}{\numberline {4}Evaluation}{25}
+\contentsline {section}{\numberline {4.1}Correctness of arrow implementations}{25}
+\contentsline {subsection}{\numberline {4.1.1}Automated testing}{25}
+\contentsline {subsubsection}{Simple arrows}{26}
+\contentsline {subsubsection}{Invertible arrows}{26}
+\contentsline {subsection}{\numberline {4.1.2}Correctness proof by decomposing into lambda calculus}{26}
+\contentsline {section}{\numberline {4.2}Syntax evaluation}{27}
+\contentsline {subsection}{\numberline {4.2.1}Arrow syntax}{27}
+\contentsline {subsubsection}{Comparison with Haskell}{27}
+\contentsline {subsection}{\numberline {4.2.2}Binding syntax}{27}
+\contentsline {subsubsection}{Username two-way binding}{27}
+\contentsline {subsubsection}{List binding from a mock database}{27}
+\contentsline {subsubsection}{Some other demo}{27}
+\contentsline {section}{\numberline {4.3}Performance testing}{27}
+\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{27}
+\contentsline {subsubsection}{Measuring technique}{28}
+\contentsline {subsubsection}{Simple function results}{28}
+\contentsline {subsubsection}{List function results}{29}
+\contentsline {subsubsection}{Overhead due to arrow chaining}{30}
+\contentsline {subsection}{\numberline {4.3.2}Binding performance}{30}
+\contentsline {chapter}{\numberline {5}Conclusion}{33}
+\contentsline {section}{\numberline {5.1}Future work}{33}
+\contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{33}
+\contentsline {chapter}{\numberline {A}Arrow laws}{35}
+\contentsline {section}{\numberline {A.1}Normal arrow laws}{35}
+\contentsline {section}{\numberline {A.2}Invertible arrow laws}{36}