updates, hierarchical

[clean-tests.git] / uds / auds.icl

diff --git a/uds/auds.icl b/uds/auds.icl
index adb7c32..a7c37ed 100644 (file)
--- a/uds/auds.icl
+++ b/uds/auds.icl
@@ -18,7 +18,7 @@ import System.FilePath
 import System.IO
 import System.Time
 
-instance MonadFail Maybe where fail _ = Nothing
+instance MonadFail ? where fail _ = ?None
 instance MonadFail [] where fail _ = []
 instance MonadFail (Either a) | fromString a where fail s = Left $ fromString s
 instance MonadFail (StateT s m) | MonadFail m where fail s = liftT $ fail s
@@ -65,7 +65,7 @@ where
                                Writing s = pure $ Writing $ Par {t & writel= \_->pure (w1, w2), left=nullShare, right=s}
                        Writing s = pure $ Writing $ Par {t & writel= \_->pure (w1, w2), left=s}
 
-lens :: (r1 -> m r) (w r1 -> m (Maybe w1)) (sds m r1 w1) -> Lens sds m r w | TC r1 & TC w1
+lens :: (r1 -> m r) (w r1 -> m (? w1)) (sds m r1 w1) -> Lens sds m r w | TC r1 & TC w1
 lens mapr mapw lens = Lens {mapr=mapr,mapw=mapw,lens=lens}
 
 instance read (Lens sds) | read sds
@@ -89,44 +89,44 @@ instance write (Lens sds) | read sds & write sds
 where
        write (Lens t=:{mapw,lens}) w = read lens >>= \v->case v of
                Read r = mapw w r >>= \w->case w of
-                       Nothing = pure $ Written ()
-                       Just w = write lens w >>= \v->case v of
+                       ?None = pure $ Written ()
+                       ?Just w = write lens w >>= \v->case v of
                                Written _ = pure $ Written ()
-                               Writing s = pure $ Writing $ Lens {t & mapw= \_ _->pure $ Just w, lens=RWPair (constShare r) s}
+                               Writing s = pure $ Writing $ Lens {t & mapw= \_ _->pure $ ?Just w, lens=RWPair (constShare r) s}
                Reading s = pure $ Writing $ Lens {t & lens=RWPair s lens}
 
 mapRead :: (r -> m r`) (sds m r w) -> Lens sds m r` w | TC r` & TC r & TC w & Monad m
-mapRead f sds = lens f (\_ _->pure Nothing) sds
+mapRead f sds = lens f (\_ _->pure ?None) sds
 
 fromDynStore :: (sds m Dynamic Dynamic) -> Lens sds m r w | TC r & TC w & MonadFail m
 fromDynStore sds = lens
        (\r->case r of
                (r :: r^) = pure r
                _ = fail "type mismatch")
-       (\w _->pure $ Just (dynamic w))
+       (\w _->pure $ ?Just (dynamic w))
        sds
 
 toDynStore :: (sds m r w) -> Lens sds m Dynamic Dynamic | TC r & TC w & MonadFail m
 toDynStore sds = lens
        (\r->pure (dynamic r))
        (\w _->case w of
-               (w :: w^) = pure $ Just w
+               (w :: w^) = pure $ ?Just w
                _ = fail "type mismatch")
        sds
 
-mapWrite :: (w` r -> m (Maybe w)) (sds m r w) -> Lens sds m r w` | TC r & TC w & TC w` & Monad m
+mapWrite :: (w` r -> m (? w)) (sds m r w) -> Lens sds m r w` | TC r & TC w & TC w` & Monad m
 mapWrite f sds = lens pure f sds
 
 indexedStore :: Int (sds m [a] [a]) -> Lens sds m a a | TC a & MonadFail m
 indexedStore idx sds = lens
        (\r->maybe (fail "out of range") pure (r !? idx))
-       (\w->pure o Just o updateAt idx w)
+       (\w->pure o ?Just o updateAt idx w)
        sds
 
 keyedStore :: k (sds m (Map k v) (Map k v)) -> Lens sds m v v | TC v & TC k & < k & MonadFail m
 keyedStore key sds = lens
        (maybe (fail "key not present") pure o 'Data.Map'.get key)
-       (\w->pure o Just o 'Data.Map'.put key w)
+       (\w->pure o ?Just o 'Data.Map'.put key w)
        sds
 
 select :: (sdsl m r1 w1) (r1 -> m (sdsr m r w)) -> Select sdsl sdsr m r w | TC r1 & TC w1 & Monad m