From afc34d76c845f1be96818addcffb4f70d9d2ea9d Mon Sep 17 00:00:00 2001
From: Gregor Kleen <gkleen@yggdrasil.li>
Date: Fri, 24 Nov 2017 17:38:54 +0100
Subject: Work on containers

---
 edit-lens/src/Control/Edit/Container.lhs | 50 ++++++++++++++++++++++++++++++--
 1 file changed, 47 insertions(+), 3 deletions(-)

(limited to 'edit-lens/src/Control/Edit')

diff --git a/edit-lens/src/Control/Edit/Container.lhs b/edit-lens/src/Control/Edit/Container.lhs
index 7d0d57c..32ec479 100644
--- a/edit-lens/src/Control/Edit/Container.lhs
+++ b/edit-lens/src/Control/Edit/Container.lhs
@@ -3,6 +3,7 @@
 module Control.Edit.Container
   ( Container(..), Shape, Content
   , ContainerEdit(..)
+  , module Control.Edit
   ) where
 
 import Control.Edit
@@ -16,19 +17,48 @@ import Control.Lens
 \end{code}
 \end{comment}
 
+\citeauthor{hofmann2012edit} stellen \emph{container} vor—eine systematische Sicht auf Datenstrukturen, die es erlaubt eine generische edit-language zu definieren.
+
+Intuitiv zerlegt die Darstellung als container eine polymorphe Datenstruktur in ihre \emph{Form} (\emph{shape}), ordnet der Form eine Menge von \emph{Positionen} zu und belegt jede Position mit einem Wert:
+
+\begin{defn}[Container-Typen]
+Ein container-type ist ein Tupel $(I, P, \text{positions})$ aus einem Modul von \emph{shapes} mit partiell geordnetem Träger $\Dom I$, einer Menge von \emph{Positionen} $P$, und einer Abbildung\footnote{In \cite{hofmann2012edit} genannt $\text{live}$} $\text{positions} \colon \Dom I \to \powerset(P)$, die jeder Form eine Menge von Positionen zuordnet, die in einem container jener Form belegt sind.
+
+Wir forden zudem, dass $\text{positions}$ monoton sein soll bzgl. der partiellen Ordnung auf $\Dom I$ und $\subseteq$ auf $\powerset P$\footnote{$\text{positions}$ ist ein Funktor von der Kategorie gegeben durch die Partielle Ordnung auf $\Dom I$ in die Kategorie von Teilmengen von $\powerset(P)$ mit Injektionen als Morphismen}.
+\end{defn}
+
 \begin{defn}[Container]
+Ein container vom Typ $(I, P, \text{positions})$ mit Werten in $X$ ist ein Tupel $(i, c)$ aus einer Form $i \in \Dom I$ und einer Funktion $c \colon \text{positions}(i) \to X$, die jeder in $i$ vorkommenden Position einen Wert aus $X$ zuweist.
+
+In Haskell sagen wir ein Typ \texttt{c} sei ein container gdw. wir einen Isomorphismus\footnote{Wir verwenden den Typ für Isomorphismen aus \cite[\texttt{Control.Lens.Iso}]{lens}, dessen genau Definition unerheblich ist für diese Arbeit} angeben können zwischen \texttt{c} und Tupeln $(i, c)$ für einen container-typ $(I, P, \text{positions})$.
+
+Hierfür unterdrücken wir den inheränten Polymorphismus von containern zunächst und ordnen stattdessen jedem monomorph instanziierten container-typ \texttt{c} einen Typ \texttt{Content c} zu.
+Polymorphe container können so mit universell quantifizierten Instanzen beschrieben werden.
+
+Wir beschränken uns zudem auf monomorphe container deren Werte-Typ der Träger eines Moduls ist, da dies, als unglückliche Folge unserer charakterisierung von Moduln durch den Typ ihrer edits, für die spätere Definition von container-edits notwendig ist.
+
 \begin{code}
 class ( Module (ModShape c)
       , Module (ModContent c)
-      , Ord (Position c)
+      , Ord (Position c) -- ^ Neccessary to form 'Set's of 'Position's
       ) => Container c where
+  -- | Since we characterise 'Module's by the type of their edits we have to associate that type with @c@.
+  --   We later introduce a type synonym for @Domain (ModShape c)@ later.
   type ModShape c :: *
+
   type Position c :: *
+
   type ModContent c :: *
+  -- ^ Analogous to 'ModShape'
+
+  -- | Compute the live positions of a shape
   positions :: Shape c -> Set (Position c)
+
+  -- | Convert between the natural representation @c@ and a view as container, that is a 'Shape c' and a value function
   deconstructed :: Iso' c (Shape c, Position c -> Content c) 
 
 constructed :: Container c => Iso' (Shape c, Position c -> Content c) c
+-- ^ Inverse of 'deconstructed', for convenience
 constructed = from deconstructed
 
 type Shape c = Domain (ModShape c)
@@ -36,19 +66,33 @@ type Content c = Domain (ModContent c)
 \end{code}
 \end{defn}
 
+\begin{defn}[Klassifikation von edits auf shapes]
+Für einen container-typ $(I, P, \text{postitions})$ klassifizieren wir die edits $\partial i \in \partial I$ wie folgt:
+
+\begin{description}
+  \item[insertions] $\forall i \in \Dom (\partial i) \colon i \cdot \partial i \geq i$
+  \item[deletions] $\forall i \in \Dom (\partial i) \colon i \cdot \partial i \leq i$
+  \item[rearrangements] $\forall i \in \Dom (\partial i) \colon \size{\text{positions}(i \cdot \partial i)} = \size{\text{positions}(i)}$
+\end{description}
+\end{defn}
+
 \begin{defn}[container-edits]
+  TODO
 \begin{code}
 data ContainerEdit c where
   Fail       :: ContainerEdit c
   ModContent :: Position c -> ModContent c -> ContainerEdit c
   ModShape   :: ModShape c -> (Shape c -> Position c -> Position c) -> ContainerEdit c
+
+type ContainerEdits c = Seq (ContainerEdit c)
 \end{code}
 \end{defn}
 
 \begin{defn}[Wirkung von container-edits]
+  TODO
 \begin{code}
-instance Container c => Module (Seq (ContainerEdit c)) where
-  type Domain (Seq (ContainerEdit c)) = c
+instance Container c => Module (ContainerEdits c) where
+  type Domain (ContainerEdits c) = c
   apply fs = over mapped (view constructed) . flip (foldM apply') fs . view deconstructed
     where
       apply' :: Container c
-- 
cgit v1.2.3