\Glspl{SDS} are an abstraction over resources that are available in the world
or in the \gls{iTasks} system. The shared data can be a file on disk, the
system time, a random integer or just some data stored in memory. The actual
\gls{SDS} is just a record containing functions on how to read and write the
source. In these functions the \CI{*IWorld} --- which in turn contains the real
\CI{*World} --- is available. Accessing the outside world is required for
interacting with it and thus the functions can access files on disk, raw
memory, other \glspl{SDS} and hardware.

The basic operations for \glspl{SDS} are get, set and update. The signatures
for these functions are shown in Listing~\ref{lst:shares}. By default, all
\glspl{SDS} are files containing a \gls{JSON} encoded version of the object and
thus are persistent between restarts of the program. Library functions for
shares residing in memory are available as well. The three main operations on
shares are atomic in the sense that during reading no other \glspl{Task} are
executed. The system provides useful functions to transform, map and combine
\glspl{SDS} using combinators. The system also provides functionality to
inspect the value of an \gls{SDS} and act upon a change. \Glspl{Task} waiting
on an \gls{SDS} to change are notified when needed. This results in low
resource usage because \glspl{Task} are never constantly inspecting \gls{SDS}
values but are notified.

\begin{lstlisting}[language=Clean,%
	label={lst:shares},caption={\Gls{SDS} functions}]
:: RWShared p r w = ... 
:: ReadWriteShared r w :== RWShared () r w
:: ROShared p r :== RWShared p () r
:: ReadOnlyShared r :== ROShared () r

:: Shared r :== ReadWriteShared r r

get ::          (ReadWriteShared r w)           -> Task r | iTask r
set :: w        (ReadWriteShared r w)           -> Task w | iTask w
upd :: (r -> w) (ReadWriteShared r w)           -> Task w | iTask r & iTask w

sharedStore :: String a -> Shared a | JSONEncode{|*|}, JSONDecode{|*|}
\end{lstlisting}

\section{Parametric Lenses}
\Glspl{SDS} can contain complex data structures such as lists, trees and even
resources in the outside world. Sometimes, an update action only updates a part
of the resource. When this happens, all waiting \glspl{Task} looking at the
resource are notified of the update. However, it may be the case that
\glspl{Task} were only looking at parts of the structure that was not updated.
To solve this problem, parametric lenses were
introduced~\cite{domoszlai_parametric_2014}.

Parametric lenses add a type variable to the \gls{SDS}. This type variable is
fixed to the void type (i.e. \CI{()}) in the given functions. When an \gls{SDS}
executes a write operation, it also provides the system with a notification
predicate. This notification predicate is a function \CI{p -> Bool} where
\CI{p} is the parametric lens type. This allows programmers to create a big
\gls{SDS}, and have \glspl{Task} only look at parts of the big \gls{SDS}. This
technique is used in the current system in memory shares. The \CI{IWorld}
contains a map that is accessible through an \gls{SDS}. While all data is
stored in the map, only \glspl{Task} looking at a specific entry are notified
when the structure is updated. The type of the parametric lens is the key in
the map.

Functionality for setting parameters is available in the system. The most
important functions are the \CI{sdsFocus} and the \CI{sdsLens} function. These
functions are listed in Listing~\ref{lst:focus}. \CI{sdsFocus} allows the
programmer to fix a parametric lens value. \CI{sdsLens} is a kind of
\CI{mapReadWrite} including access to the parametric lens value. This allows
the creation of, for example, \glspl{SDS} that only read and write to parts of
the original \gls{SDS}.

\begin{lstlisting}[language=Clean,label={lst:focus},
	caption={Parametric lens functions}]
sdsFocus :: p (RWShared p r w) -> RWShared p` r w | iTask p

:: SDSNotifyPred p :== p -> Bool

:: SDSLensRead p r rs     = SDSRead        (p -> rs -> MaybeError TaskException r)
                          | SDSReadConst   (p -> r)
:: SDSLensWrite p w rs ws = SDSWrite       (p -> rs -> w -> MaybeError TaskException (Maybe ws))
                          | SDSWriteConst  (p -> w -> MaybeError TaskException (Maybe ws))
:: SDSLensNotify p w rs   = SDSNotify      (p -> rs -> w -> SDSNotifyPred p)
                          | SDSNotifyConst (p -> w -> SDSNotifyPred p)

sdsLens :: String (p -> ps) (SDSLensRead p r rs) (SDSLensWrite p w rs ws) (SDSLensNotify p w rs)
	(RWShared ps rs ws) -> RWShared p r w | iTask ps
\end{lstlisting}
