packages feed

bowtie 0.6.0 → 0.7.0

raw patch · 5 files changed

+50/−27 lines, 5 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

- Bowtie.SMap: class (NonMember x zs) => Without (x :: Symbol) (xs :: [Symbol]) (zs :: [Symbol]) | x xs -> zs
- Bowtie.SMap: instance (zs GHC.Types.~ Bowtie.SMap.WithoutF x '[]) => Bowtie.SMap.Without x '[] zs
- Bowtie.SMap: instance (zs GHC.Types.~ Bowtie.SMap.WithoutF x (y : ys), Bowtie.SMap.NonMember x zs) => Bowtie.SMap.Without x (y : ys) zs
+ Bowtie.Memo: instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Bowtie.Memo.MemoF f k)
+ Bowtie.Memo: instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Bowtie.Memo.MemoF f k)
+ Bowtie.SMap: class Merged (xs :: [Symbol]) (ys :: [Symbol]) (zs :: [Symbol]) | xs ys -> zs
+ Bowtie.SMap: class Unioned (xs :: [Symbol]) (ys :: [Symbol]) (zs :: [Symbol]) | xs ys -> zs
+ Bowtie.SMap: instance (Bowtie.SMap.MergedF xs ys GHC.Types.~ ws, Bowtie.SMap.InsertedF x ws GHC.Types.~ zs) => Bowtie.SMap.Merged (x : xs) ys zs
+ Bowtie.SMap: instance (Bowtie.SMap.NonMember x ys, Bowtie.SMap.UnionedF xs ys GHC.Types.~ zs) => Bowtie.SMap.Unioned (x : xs) ys (x : zs)
+ Bowtie.SMap: instance Bowtie.SMap.Merged '[] ys ys
+ Bowtie.SMap: instance Bowtie.SMap.Unioned '[] ys ys
+ Bowtie.SMap: keysSMap :: forall d (xs :: [Symbol]). SMap d xs -> [String]
+ Bowtie.SMap: mergeSMap :: forall (xs :: [Symbol]) (ys :: [Symbol]) (zs :: [Symbol]) d. Merged xs ys zs => MergeFn d -> SMap d xs -> SMap d ys -> SMap d zs
+ Bowtie.SMap: type MergeFn d = forall (s :: Symbol). KnownSymbol s => Proxy s -> Val d s -> Val d s -> Val d s
+ Bowtie.SMap: unionSMap :: forall (xs :: [Symbol]) (ys :: [Symbol]) (zs :: [Symbol]) d. Unioned xs ys zs => SMap d xs -> SMap d ys -> SMap d zs
- Bowtie.Anno: annoUnitM :: Applicative m => v -> ReaderT k m (Anno k v)
+ Bowtie.Anno: annoUnitM :: forall (m :: Type -> Type) v k. Applicative m => v -> ReaderT k m (Anno k v)
- Bowtie.Attr: attrLens :: HasAttr d s k => Proxy d -> Proxy s -> Lens' k (Val d s)
+ Bowtie.Attr: attrLens :: forall d (s :: Symbol) k. HasAttr d s k => Proxy d -> Proxy s -> Lens' k (Val d s)
- Bowtie.Attr: attrSetter :: WithAttr d s k j => Proxy d -> Proxy s -> Setter j k () (Val d s)
+ Bowtie.Attr: attrSetter :: forall d (s :: Symbol) k j. WithAttr d s k j => Proxy d -> Proxy s -> Setter j k () (Val d s)
- Bowtie.Attr: class HasAttr (d :: Type) (s :: Symbol) (k :: Type)
+ Bowtie.Attr: class HasAttr d (s :: Symbol) k
- Bowtie.Attr: class (HasAttr d s k) => WithAttr (d :: Type) (s :: Symbol) (k :: Type) (j :: Type) | d s k -> j, d s j -> k
+ Bowtie.Attr: class HasAttr d s k => WithAttr d (s :: Symbol) k j | d s k -> j, d s j -> k
- Bowtie.Attr: memoWithAttr :: (WithAttr d s k j, Functor f) => Proxy d -> Proxy s -> (MemoF f j (Memo f k) -> Val d s) -> Memo f j -> Memo f k
+ Bowtie.Attr: memoWithAttr :: forall d (s :: Symbol) k j (f :: Type -> Type). (WithAttr d s k j, Functor f) => Proxy d -> Proxy s -> (MemoF f j (Memo f k) -> Val d s) -> Memo f j -> Memo f k
- Bowtie.Attr: memoWithAttrM :: (WithAttr d s k j, Traversable f, Monad m) => Proxy d -> Proxy s -> (MemoF f j (Memo f k) -> m (Val d s)) -> Memo f j -> m (Memo f k)
+ Bowtie.Attr: memoWithAttrM :: forall d (s :: Symbol) k j (f :: Type -> Type) m. (WithAttr d s k j, Traversable f, Monad m) => Proxy d -> Proxy s -> (MemoF f j (Memo f k) -> m (Val d s)) -> Memo f j -> m (Memo f k)
- Bowtie.Attr: memoWithoutAttr :: (WithAttr d s k j, Functor f) => Proxy d -> Proxy s -> Memo f k -> Memo f j
+ Bowtie.Attr: memoWithoutAttr :: forall d (s :: Symbol) k j (f :: Type -> Type). (WithAttr d s k j, Functor f) => Proxy d -> Proxy s -> Memo f k -> Memo f j
- Bowtie.Fix: Fix :: f (Fix f) -> Fix f
+ Bowtie.Fix: Fix :: f (Fix f) -> Fix (f :: Type -> Type)
- Bowtie.Fix: [unFix] :: Fix f -> f (Fix f)
+ Bowtie.Fix: [unFix] :: Fix (f :: Type -> Type) -> f (Fix f)
- Bowtie.Fix: mkFix :: (Recursive t, Base t ~ f) => t -> Fix f
+ Bowtie.Fix: mkFix :: forall t (f :: Type -> Type). (Recursive t, Base t ~ f) => t -> Fix f
- Bowtie.Fix: newtype Fix f
+ Bowtie.Fix: newtype Fix (f :: Type -> Type)
- Bowtie.Fix: transFix :: Functor f => (forall x. f x -> g x) -> Fix f -> Fix g
+ Bowtie.Fix: transFix :: Functor f => (forall x. () => f x -> g x) -> Fix f -> Fix g
- Bowtie.Fix: unMkFix :: (Corecursive t, Base t ~ f) => Fix f -> t
+ Bowtie.Fix: unMkFix :: forall t (f :: Type -> Type). (Corecursive t, Base t ~ f) => Fix f -> t
- Bowtie.Foldable: class (Bifunctor (Base1 f), Functor f) => Corecursive1 f
+ Bowtie.Foldable: class (Bifunctor Base1 f, Functor f) => Corecursive1 (f :: Type -> Type)
- Bowtie.Foldable: class (Bifunctor (Base1 f), Functor f) => Recursive1 f
+ Bowtie.Foldable: class (Bifunctor Base1 f, Functor f) => Recursive1 (f :: Type -> Type)
- Bowtie.Foldable: fmapViaBi :: (Recursive1 f, Corecursive1 f, Base1 f ~ g) => (a -> b) -> f a -> f b
+ Bowtie.Foldable: fmapViaBi :: forall f (g :: Type -> Type -> Type) a b. (Recursive1 f, Corecursive1 f, Base1 f ~ g) => (a -> b) -> f a -> f b
- Bowtie.Foldable: foldrViaBi :: (Recursive1 f, Base1 f ~ g, Bifoldable g) => (a -> b -> b) -> b -> f a -> b
+ Bowtie.Foldable: foldrViaBi :: forall f (g :: Type -> Type -> Type) a b. (Recursive1 f, Base1 f ~ g, Bifoldable g) => (a -> b -> b) -> b -> f a -> b
- Bowtie.Foldable: traverseViaBi :: (Recursive1 f, Corecursive1 f, Base1 f ~ g, Bitraversable g, Applicative m) => (a -> m b) -> f a -> m (f b)
+ Bowtie.Foldable: traverseViaBi :: forall f (g :: Type -> Type -> Type) m a b. (Recursive1 f, Corecursive1 f, Base1 f ~ g, Bitraversable g, Applicative m) => (a -> m b) -> f a -> m (f b)
- Bowtie.Free: Free :: FreeF f a (Free f a) -> Free f a
+ Bowtie.Free: Free :: FreeF f a (Free f a) -> Free (f :: Type -> Type) a
- Bowtie.Free: FreeEmbedF :: !f r -> FreeF f a r
+ Bowtie.Free: FreeEmbedF :: !f r -> FreeF (f :: k -> Type) a (r :: k)
- Bowtie.Free: FreePureF :: !a -> FreeF f a r
+ Bowtie.Free: FreePureF :: !a -> FreeF (f :: k -> Type) a (r :: k)
- Bowtie.Free: FreeT :: m (FreeF f a (FreeT f m a)) -> FreeT f m a
+ Bowtie.Free: FreeT :: m (FreeF f a (FreeT f m a)) -> FreeT (f :: Type -> Type) (m :: Type -> Type) a
- Bowtie.Free: [unFreeT] :: FreeT f m a -> m (FreeF f a (FreeT f m a))
+ Bowtie.Free: [unFreeT] :: FreeT (f :: Type -> Type) (m :: Type -> Type) a -> m (FreeF f a (FreeT f m a))
- Bowtie.Free: [unFree] :: Free f a -> FreeF f a (Free f a)
+ Bowtie.Free: [unFree] :: Free (f :: Type -> Type) a -> FreeF f a (Free f a)
- Bowtie.Free: data FreeF f a r
+ Bowtie.Free: data FreeF (f :: k -> Type) a (r :: k)
- Bowtie.Free: hoistFreeT :: (Functor f, Functor m) => (forall a. m a -> n a) -> FreeT f m b -> FreeT f n b
+ Bowtie.Free: hoistFreeT :: forall (f :: Type -> Type) m n b. (Functor f, Functor m) => (forall a. () => m a -> n a) -> FreeT f m b -> FreeT f n b
- Bowtie.Free: joinFreeT :: (Monad m, Traversable f) => FreeT f m a -> m (Free f a)
+ Bowtie.Free: joinFreeT :: forall m (f :: Type -> Type) a. (Monad m, Traversable f) => FreeT f m a -> m (Free f a)
- Bowtie.Free: liftFreeT :: (Functor f, Applicative m) => f a -> FreeT f m a
+ Bowtie.Free: liftFreeT :: forall f (m :: Type -> Type) a. (Functor f, Applicative m) => f a -> FreeT f m a
- Bowtie.Free: newtype Free f a
+ Bowtie.Free: newtype Free (f :: Type -> Type) a
- Bowtie.Free: newtype FreeT f m a
+ Bowtie.Free: newtype FreeT (f :: Type -> Type) (m :: Type -> Type) a
- Bowtie.Free: substFree :: (Corecursive t, f ~ Base t) => (a -> t) -> Free f a -> t
+ Bowtie.Free: substFree :: forall t (f :: Type -> Type) a. (Corecursive t, f ~ Base t) => (a -> t) -> Free f a -> t
- Bowtie.Free: transFreeT :: (Functor g, Monad m) => (forall a. f a -> g a) -> FreeT f m b -> FreeT g m b
+ Bowtie.Free: transFreeT :: forall g (m :: Type -> Type) f b. (Functor g, Monad m) => (forall a. () => f a -> g a) -> FreeT f m b -> FreeT g m b
- Bowtie.Jot: Jot :: JotF g k a (Jot g k a) -> Jot g k a
+ Bowtie.Jot: Jot :: JotF g k a (Jot g k a) -> Jot (g :: Type -> Type -> Type) k a
- Bowtie.Jot: JotF :: Anno k (g a r) -> JotF g k a r
+ Bowtie.Jot: JotF :: Anno k2 (g a r) -> JotF (g :: k -> k1 -> Type) k2 (a :: k) (r :: k1)
- Bowtie.Jot: [unJotF] :: JotF g k a r -> Anno k (g a r)
+ Bowtie.Jot: [unJotF] :: JotF (g :: k -> k1 -> Type) k2 (a :: k) (r :: k1) -> Anno k2 (g a r)
- Bowtie.Jot: [unJot] :: Jot g k a -> JotF g k a (Jot g k a)
+ Bowtie.Jot: [unJot] :: Jot (g :: Type -> Type -> Type) k a -> JotF g k a (Jot g k a)
- Bowtie.Jot: jotExtend :: Bifunctor g => (Jot g k a -> x) -> Jot g k a -> Jot g x a
+ Bowtie.Jot: jotExtend :: forall (g :: Type -> Type -> Type) k a x. Bifunctor g => (Jot g k a -> x) -> Jot g k a -> Jot g x a
- Bowtie.Jot: jotFKey :: JotF g k a r -> k
+ Bowtie.Jot: jotFKey :: forall {k1} {k2} (g :: k1 -> k2 -> Type) k3 (a :: k1) (r :: k2). JotF g k3 a r -> k3
- Bowtie.Jot: jotFVal :: JotF g k a r -> g a r
+ Bowtie.Jot: jotFVal :: forall {k1} {k2} g k3 (a :: k1) (r :: k2). JotF g k3 a r -> g a r
- Bowtie.Jot: jotKey :: Jot g k a -> k
+ Bowtie.Jot: jotKey :: forall (g :: Type -> Type -> Type) k a. Jot g k a -> k
- Bowtie.Jot: newtype Jot g k a
+ Bowtie.Jot: newtype Jot (g :: Type -> Type -> Type) k a
- Bowtie.Jot: newtype JotF g k a r
+ Bowtie.Jot: newtype JotF (g :: k -> k1 -> Type) k2 (a :: k) (r :: k1)
- Bowtie.Jot: pattern JotFP :: k -> g a r -> JotF g k a r
+ Bowtie.Jot: pattern JotFP :: forall {k1} {k2} k3 g a r. k3 -> g a r -> JotF g k3 a r
- Bowtie.Jot: transJot :: Bifunctor g => (forall x. g a x -> h a x) -> Jot g k a -> Jot h k a
+ Bowtie.Jot: transJot :: Bifunctor g => (forall x. () => g a x -> h a x) -> Jot g k a -> Jot h k a
- Bowtie.Jot: unMkJot :: (Corecursive1 t, Base1 t ~ g) => Jot g k a -> t a
+ Bowtie.Jot: unMkJot :: forall t (g :: Type -> Type -> Type) k a. (Corecursive1 t, Base1 t ~ g) => Jot g k a -> t a
- Bowtie.Knot: Knot :: g a (Knot g a) -> Knot g a
+ Bowtie.Knot: Knot :: g a (Knot g a) -> Knot (g :: Type -> Type -> Type) a
- Bowtie.Knot: [unKnot] :: Knot g a -> g a (Knot g a)
+ Bowtie.Knot: [unKnot] :: Knot (g :: Type -> Type -> Type) a -> g a (Knot g a)
- Bowtie.Knot: mkKnot :: (Recursive1 f, Base1 f ~ g) => f a -> Knot g a
+ Bowtie.Knot: mkKnot :: forall f (g :: Type -> Type -> Type) a. (Recursive1 f, Base1 f ~ g) => f a -> Knot g a
- Bowtie.Knot: newtype Knot g a
+ Bowtie.Knot: newtype Knot (g :: Type -> Type -> Type) a
- Bowtie.Knot: transKnot :: Bifunctor g => (forall x y. g x y -> h x y) -> Knot g a -> Knot h a
+ Bowtie.Knot: transKnot :: Bifunctor g => (forall x y. () => g x y -> h x y) -> Knot g a -> Knot h a
- Bowtie.Knot: unMkKnot :: (Corecursive1 f, Base1 f ~ g) => Knot g a -> f a
+ Bowtie.Knot: unMkKnot :: forall f (g :: Type -> Type -> Type) a. (Corecursive1 f, Base1 f ~ g) => Knot g a -> f a
- Bowtie.Memo: Memo :: MemoF f k (Memo f k) -> Memo f k
+ Bowtie.Memo: Memo :: MemoF f k (Memo f k) -> Memo (f :: Type -> Type) k
- Bowtie.Memo: MemoF :: Anno k (f r) -> MemoF f k r
+ Bowtie.Memo: MemoF :: Anno k1 (f r) -> MemoF (f :: k -> Type) k1 (r :: k)
- Bowtie.Memo: [unMemoF] :: MemoF f k r -> Anno k (f r)
+ Bowtie.Memo: [unMemoF] :: MemoF (f :: k -> Type) k1 (r :: k) -> Anno k1 (f r)
- Bowtie.Memo: [unMemo] :: Memo f k -> MemoF f k (Memo f k)
+ Bowtie.Memo: [unMemo] :: Memo (f :: Type -> Type) k -> MemoF f k (Memo f k)
- Bowtie.Memo: memoExtend :: Functor f => (Memo f k -> x) -> Memo f k -> Memo f x
+ Bowtie.Memo: memoExtend :: forall (f :: Type -> Type) k x. Functor f => (Memo f k -> x) -> Memo f k -> Memo f x
- Bowtie.Memo: memoFKey :: MemoF f k r -> k
+ Bowtie.Memo: memoFKey :: forall {k1} (f :: k1 -> Type) k2 (r :: k1). MemoF f k2 r -> k2
- Bowtie.Memo: memoFVal :: MemoF f k r -> f r
+ Bowtie.Memo: memoFVal :: forall {k1} f k2 (r :: k1). MemoF f k2 r -> f r
- Bowtie.Memo: memoFix :: Functor f => Memo f k -> Fix f
+ Bowtie.Memo: memoFix :: forall (f :: Type -> Type) k. Functor f => Memo f k -> Fix f
- Bowtie.Memo: memoKey :: Memo f k -> k
+ Bowtie.Memo: memoKey :: forall (f :: Type -> Type) k. Memo f k -> k
- Bowtie.Memo: memoStructEq :: (Functor f, Eq (f (Fix f))) => Memo f k -> Memo f k -> Bool
+ Bowtie.Memo: memoStructEq :: forall (f :: Type -> Type) k. (Functor f, Eq (f (Fix f))) => Memo f k -> Memo f k -> Bool
- Bowtie.Memo: newtype Memo f k
+ Bowtie.Memo: newtype Memo (f :: Type -> Type) k
- Bowtie.Memo: newtype MemoF f k r
+ Bowtie.Memo: newtype MemoF (f :: k -> Type) k1 (r :: k)
- Bowtie.Memo: pattern MemoFP :: k -> f r -> MemoF f k r
+ Bowtie.Memo: pattern MemoFP :: forall {k1} k2 f r. k2 -> f r -> MemoF f k2 r
- Bowtie.Memo: reMkMemo :: Functor f => (MemoF f j (Memo f k) -> k) -> Memo f j -> Memo f k
+ Bowtie.Memo: reMkMemo :: forall (f :: Type -> Type) j k. Functor f => (MemoF f j (Memo f k) -> k) -> Memo f j -> Memo f k
- Bowtie.Memo: reMkMemoM :: (Traversable f, Monad m) => (MemoF f j (Memo f k) -> m k) -> Memo f j -> m (Memo f k)
+ Bowtie.Memo: reMkMemoM :: forall (f :: Type -> Type) m j k. (Traversable f, Monad m) => (MemoF f j (Memo f k) -> m k) -> Memo f j -> m (Memo f k)
- Bowtie.Memo: transMemo :: Functor f => (forall x. f x -> g x) -> Memo f k -> Memo g k
+ Bowtie.Memo: transMemo :: Functor f => (forall x. () => f x -> g x) -> Memo f k -> Memo g k
- Bowtie.Memo: unMkMemo :: (Corecursive t, Base t ~ f) => Memo f k -> t
+ Bowtie.Memo: unMkMemo :: forall t (f :: Type -> Type) k. (Corecursive t, Base t ~ f) => Memo f k -> t
- Bowtie.Rewrite: RwT :: ReaderT (NESeq k) (ExceptT (AnnoErr k e) m) a -> RwT k e m a
+ Bowtie.Rewrite: RwT :: ReaderT (NESeq k) (ExceptT (AnnoErr k e) m) a -> RwT k e (m :: Type -> Type) a
- Bowtie.Rewrite: [unRwT] :: RwT k e m a -> ReaderT (NESeq k) (ExceptT (AnnoErr k e) m) a
+ Bowtie.Rewrite: [unRwT] :: RwT k e (m :: Type -> Type) a -> ReaderT (NESeq k) (ExceptT (AnnoErr k e) m) a
- Bowtie.Rewrite: askRw :: Monad m => RwT k e m (NESeq k)
+ Bowtie.Rewrite: askRw :: forall (m :: Type -> Type) k e. Monad m => RwT k e m (NESeq k)
- Bowtie.Rewrite: asksRw :: Monad m => (NESeq k -> a) -> RwT k e m a
+ Bowtie.Rewrite: asksRw :: forall (m :: Type -> Type) k a e. Monad m => (NESeq k -> a) -> RwT k e m a
- Bowtie.Rewrite: newtype RwT k e m a
+ Bowtie.Rewrite: newtype RwT k e (m :: Type -> Type) a
- Bowtie.Rewrite: peekRw :: Monad m => RwT k e m k
+ Bowtie.Rewrite: peekRw :: forall (m :: Type -> Type) k e. Monad m => RwT k e m k
- Bowtie.Rewrite: peeksRw :: Monad m => (k -> a) -> RwT k e m a
+ Bowtie.Rewrite: peeksRw :: forall (m :: Type -> Type) k a e. Monad m => (k -> a) -> RwT k e m a
- Bowtie.Rewrite: pushRw :: Monad m => k -> RwT k e m a -> RwT k e m a
+ Bowtie.Rewrite: pushRw :: forall (m :: Type -> Type) k e a. Monad m => k -> RwT k e m a -> RwT k e m a
- Bowtie.Rewrite: throwRw :: Monad m => e -> RwT k e m a
+ Bowtie.Rewrite: throwRw :: forall (m :: Type -> Type) e k a. Monad m => e -> RwT k e m a
- Bowtie.SMap: class (NonMember x zs) => Deleted (x :: Symbol) (xs :: [Symbol]) (zs :: [Symbol]) | x xs -> zs
+ Bowtie.SMap: class NonMember x zs => Deleted (x :: Symbol) (xs :: [Symbol]) (zs :: [Symbol]) | x xs -> zs
- Bowtie.SMap: class (Member x zs) => Inserted (x :: Symbol) (xs :: [Symbol]) (zs :: [Symbol]) | x xs -> zs
+ Bowtie.SMap: class Member x zs => Inserted (x :: Symbol) (xs :: [Symbol]) (zs :: [Symbol]) | x xs -> zs
- Bowtie.SMap: data SMap (d :: Type) (xs :: [Symbol])
+ Bowtie.SMap: data SMap d (xs :: [Symbol])
- Bowtie.SMap: deleteSMap :: (KnownSymbol s, Deleted s xs zs) => Proxy s -> SMap d xs -> SMap d zs
+ Bowtie.SMap: deleteSMap :: forall (s :: Symbol) (xs :: [Symbol]) (zs :: [Symbol]) d. (KnownSymbol s, Deleted s xs zs) => Proxy s -> SMap d xs -> SMap d zs
- Bowtie.SMap: emptySMap :: SMap d '[]
+ Bowtie.SMap: emptySMap :: SMap d ('[] :: [Symbol])
- Bowtie.SMap: indexSMap :: (KnownSymbol s, Member s xs) => Proxy s -> SMap d xs -> Val d s
+ Bowtie.SMap: indexSMap :: forall (s :: Symbol) (xs :: [Symbol]) d. (KnownSymbol s, Member s xs) => Proxy s -> SMap d xs -> Val d s
- Bowtie.SMap: insertSMap :: (KnownSymbol s, Inserted s xs zs) => Proxy s -> Val d s -> SMap d xs -> SMap d zs
+ Bowtie.SMap: insertSMap :: forall (s :: Symbol) (xs :: [Symbol]) (zs :: [Symbol]) d. (KnownSymbol s, Inserted s xs zs) => Proxy s -> Val d s -> SMap d xs -> SMap d zs
- Bowtie.SMap: reorderSMap :: Reordered xs zs => SMap d xs -> SMap d zs
+ Bowtie.SMap: reorderSMap :: forall (xs :: [Symbol]) (zs :: [Symbol]) d. Reordered xs zs => SMap d xs -> SMap d zs
- Bowtie.SMap: singletonSMap :: KnownSymbol s => Proxy s -> Val d s -> SMap d '[s]
+ Bowtie.SMap: singletonSMap :: forall (s :: Symbol) d. KnownSymbol s => Proxy s -> Val d s -> SMap d '[s]
- Bowtie.SMap: type family Val (d :: Type) (s :: Symbol) :: Type
+ Bowtie.SMap: type family Val d (s :: Symbol)
- Bowtie.SMap: updateSMap :: (KnownSymbol s, Member s xs) => Proxy s -> Val d s -> SMap d xs -> SMap d xs
+ Bowtie.SMap: updateSMap :: forall (s :: Symbol) (xs :: [Symbol]) d. (KnownSymbol s, Member s xs) => Proxy s -> Val d s -> SMap d xs -> SMap d xs

Files

bowtie.cabal view
@@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.37.0.+-- This file has been generated from package.yaml by hpack version 0.38.0. -- -- see: https://github.com/sol/hpack  name:           bowtie-version:        0.6.0+version:        0.7.0 synopsis:       Tying knots in polynomial functors description:    Please see the README on GitHub at <https://github.com/ejconlon/bowtie#readme> homepage:       https://github.com/ejconlon/bowtie#readme
src/Bowtie/Free.hs view
@@ -5,9 +5,7 @@ -- See https://hackage.haskell.org/package/free-5.1.7/docs/Control-Monad-Trans-Free.html module Bowtie.Free   ( FreeF (..)-  , Free (..)-  , pattern FreeEmbed-  , pattern FreePure+  , Free (.., FreeEmbed, FreePure)   , substFree   , liftFree   , iterFree
src/Bowtie/Jot.hs view
@@ -1,12 +1,10 @@ {-# LANGUAGE UndecidableInstances #-}  module Bowtie.Jot-  ( JotF (..)-  , pattern JotFP+  ( JotF (.., JotFP)   , jotFKey   , jotFVal-  , Jot (..)-  , pattern JotP+  , Jot (.., JotP)   , mkJot   , unMkJot   , annoJot
src/Bowtie/Memo.hs view
@@ -1,12 +1,10 @@ {-# LANGUAGE UndecidableInstances #-}  module Bowtie.Memo-  ( MemoF (..)-  , pattern MemoFP+  ( MemoF (.., MemoFP)   , memoFKey   , memoFVal-  , Memo (..)-  , pattern MemoP+  , Memo (.., MemoP)   , mkMemo   , mkMemoM   , reMkMemo@@ -37,7 +35,7 @@  -- | The base functor for a 'Memo' newtype MemoF f k r = MemoF {unMemoF :: Anno k (f r)}-  deriving stock (Show, Functor)+  deriving stock (Show, Functor, Foldable, Traversable)   deriving newtype (Eq, Ord)  pattern MemoFP :: k -> f r -> MemoF f k r
src/Bowtie/SMap.hs view
@@ -15,17 +15,22 @@   , Member   , NonMember   , Inserted-  , Without   , Deleted   , Reordered+  , Unioned+  , Merged   , SMap   , emptySMap+  , unionSMap+  , MergeFn+  , mergeSMap   , singletonSMap   , indexSMap   , updateSMap   , insertSMap   , deleteSMap   , reorderSMap+  , keysSMap   ) where @@ -36,9 +41,10 @@ import Data.GADT.Compare (GCompare (..), GEq (..), GOrdering (..), defaultCompare, defaultEq) import Data.Kind (Type) import Data.Proxy (Proxy (..))+import Data.Some (Some (..)) import Data.Type.Bool (type (||)) import Data.Type.Equality ((:~:) (..), type (==))-import GHC.TypeLits (KnownSymbol, OrderingI (..), Symbol, cmpSymbol, sameSymbol)+import GHC.TypeLits (KnownSymbol, OrderingI (..), Symbol, cmpSymbol, sameSymbol, symbolVal)  type family Val (d :: Type) (s :: Symbol) :: Type @@ -69,6 +75,9 @@ key :: (KnownSymbol s, v ~ Val d s) => Proxy s -> Key d v key = flip Key Proxy +keyString :: Key d v -> String+keyString (Key p _) = symbolVal p+ type DM (d :: Type) = DMap (Key d) Identity  emptyDM :: DM d@@ -115,17 +124,6 @@  instance (zs ~ InsertedF x (y : ys), Member x zs) => Inserted x (y : ys) zs -type family WithoutF (x :: Symbol) (xs :: [Symbol]) :: [Symbol] where-  WithoutF x '[] = '[]-  WithoutF x (x : zs) = zs-  WithoutF x (y : zs) = y : WithoutF x zs--class (NonMember x zs) => Without (x :: Symbol) (xs :: [Symbol]) (zs :: [Symbol]) | x xs -> zs--instance (zs ~ WithoutF x '[]) => Without x '[] zs--instance (zs ~ WithoutF x (y : ys), NonMember x zs) => Without x (y : ys) zs- type family DeletedF (x :: Symbol) (xs :: [Symbol]) :: [Symbol] where   DeletedF x (x : zs) = zs   DeletedF x (y : zs) = y : DeletedF x zs@@ -140,11 +138,39 @@  instance (Reordered xs (DeletedF x zs)) => Reordered (x : xs) zs +type family UnionedF (xs :: [Symbol]) (ys :: [Symbol]) :: [Symbol] where+  UnionedF '[] ys = ys+  UnionedF (x : xs) ys = UnionedF xs (InsertedF x ys)++class Unioned (xs :: [Symbol]) (ys :: [Symbol]) (zs :: [Symbol]) | xs ys -> zs++instance Unioned '[] ys ys++instance (NonMember x ys, UnionedF xs ys ~ zs) => Unioned (x : xs) ys (x : zs)++type family MergedF (xs :: [Symbol]) (ys :: [Symbol]) :: [Symbol] where+  MergedF '[] ys = ys+  MergedF (x : xs) ys = MergedF xs (InsertedF x ys)++class Merged (xs :: [Symbol]) (ys :: [Symbol]) (zs :: [Symbol]) | xs ys -> zs++instance Merged '[] ys ys++instance (MergedF xs ys ~ ws, InsertedF x ws ~ zs) => Merged (x : xs) ys zs+ newtype SMap (d :: Type) (xs :: [Symbol]) = SMap (DM d)  emptySMap :: SMap d '[] emptySMap = SMap emptyDM +unionSMap :: (Unioned xs ys zs) => SMap d xs -> SMap d ys -> SMap d zs+unionSMap (SMap dmx) (SMap dmy) = SMap (DMap.union dmx dmy)++type MergeFn (d :: Type) = forall (s :: Symbol). (KnownSymbol s) => Proxy s -> Val d s -> Val d s -> Val d s++mergeSMap :: (Merged xs ys zs) => MergeFn d -> SMap d xs -> SMap d ys -> SMap d zs+mergeSMap f (SMap dmx) (SMap dmy) = SMap (DMap.unionWithKey (\(Key p _) (Identity vx) (Identity vy) -> Identity (f p vx vy)) dmx dmy)+ singletonSMap :: (KnownSymbol s) => Proxy s -> Val d s -> SMap d '[s] singletonSMap ps v = SMap (singletonDM ps v) @@ -162,3 +188,6 @@  reorderSMap :: (Reordered xs zs) => SMap d xs -> SMap d zs reorderSMap = coerce++keysSMap :: SMap d xs -> [String]+keysSMap (SMap m) = fmap (\(Some k) -> keyString k) (DMap.keys m)