eb9d786 · reflex · git.iko.soy

git.iko.soy/reflex

Fix warnings

commiteb9d7865c8f5250666360b3e5d510a6e2f331d63 authorAli Abrar <aliabrar@gmail.com> dateSun 17 Mar 2019, 23:51 (8 years ago) parent0b3ca54

2 files changed+13−14

compare with develop

unifiedsplit

src/Generics/SOP/DMapUtilities.hs+9−9 src/Generics/SOP/Distribute.hs+4−5

src/Generics/SOP/DMapUtilities.hs+9−9

@@ -96,7 +96,7 @@ nsToDSum = hcollapse . ap_NS (hmap (\tag -> (fn $ \val -> K (tag :=> val))) make

9696-}

9797

9898-- |Convert a 'DS.DSum' indexed by 'TypeListTag' xs into a 'NS' indexed by xs

99−dSumToNS :: SListI xs => DS.DSum (TypeListTag xs) f -> NS f xs

99+dSumToNS :: DS.DSum (TypeListTag xs) f -> NS f xs

100100dSumToNS (tag :=> fa) = go tag fa

101101 where

102102 go::TypeListTag ys y -> f y -> NS f ys

@@ -107,7 +107,7 @@ dSumToNS (tag :=> fa) = go tag fa

107107makeTypeListTagNP :: SListI xs => NP (TypeListTag xs) xs

108108makeTypeListTagNP = go sList

109109 where

110− go :: forall ys. SListI ys => SList ys -> NP (TypeListTag ys) ys

110+ go :: SList ys -> NP (TypeListTag ys) ys

111111 go SNil = Nil

112112 go SCons = TLHead :* hmap TLTail (go sList)

113113

@@ -124,7 +124,7 @@ type family FunctorWrapTypeListOfLists (f :: * -> *) (xss :: [[*]]) :: [[*]] whe

124124-- composition has been moved to the type-list. The values in the product remain the same (up to types representing composition of the functors). E.g.,

125125--

126126-- > (f :.: g) 2 :* (f :.: g) 3.0 :* 'Nil :: NP (f :.: g) '[Int,Double] -> f (g 2) :* f (g 3.0) :* 'Nil :: NP f '[g Int, g Double]

127−npUnCompose :: forall f g xs. SListI xs => NP (f :.: g) xs -> NP f (FunctorWrapTypeList g xs)

127+npUnCompose :: forall f g xs. NP (f :.: g) xs -> NP f (FunctorWrapTypeList g xs)

128128npUnCompose = go

129129 where

130130 go :: NP (f :.: g) ys -> NP f (FunctorWrapTypeList g ys)

@@ -132,9 +132,9 @@ npUnCompose = go

132132 go (fgx :* npTail) = unComp fgx :* go npTail

133133

134134-- | UnCompose all of the 'NP's in an "NS (NP f) xss".

135−nsOfnpUnCompose :: forall f g xss. (SListI xss, SListI2 xss) => NS (NP (f :.: g)) xss -> NS (NP f) (FunctorWrapTypeListOfLists g xss)

135+nsOfnpUnCompose :: forall f g xss. (SListI2 xss) => NS (NP (f :.: g)) xss -> NS (NP f) (FunctorWrapTypeListOfLists g xss)

136136nsOfnpUnCompose = go sList where

137− go :: forall yss. (SListI yss, SListI2 yss) => SList yss -> NS (NP (f :.: g)) yss -> NS (NP f) (FunctorWrapTypeListOfLists g yss)

137+ go :: forall yss. (SListI2 yss) => SList yss -> NS (NP (f :.: g)) yss -> NS (NP f) (FunctorWrapTypeListOfLists g yss)

138138 go SNil _ = error "An NS cannot be empty"

139139 go SCons (Z np) = Z (npUnCompose np)

140140 go SCons (S ns') = S (go sList ns')

@@ -145,15 +145,15 @@ nsOfnpUnCompose = go sList where

145145npReCompose :: forall f g xs. SListI xs => NP f (FunctorWrapTypeList g xs) -> NP (f :.: g) xs

146146npReCompose = go sList

147147 where

148− go :: forall ys. SListI ys => SList ys -> NP f (FunctorWrapTypeList g ys) -> NP (f :.: g) ys

148+ go :: forall ys. SList ys -> NP f (FunctorWrapTypeList g ys) -> NP (f :.: g) ys

149149 go SNil Nil = Nil

150150 go SCons (fgx :* npTail) = Comp fgx :* go sList npTail

151151

152152-- | ReCompose all the 'NP's in an "NS (NP f) xss".

153−nsOfnpReCompose :: forall f g xss. (SListI xss, SListI2 xss) => NS (NP f) (FunctorWrapTypeListOfLists g xss) -> NS (NP (f :.: g)) xss

153+nsOfnpReCompose :: forall f g xss. (SListI2 xss) => NS (NP f) (FunctorWrapTypeListOfLists g xss) -> NS (NP (f :.: g)) xss

154154nsOfnpReCompose = go sList

155155 where

156− go :: forall yss. (SListI2 yss, SListI yss) => SList yss -> NS (NP f) (FunctorWrapTypeListOfLists g yss) -> NS (NP (f :.: g)) yss

156+ go :: forall yss. (SListI2 yss) => SList yss -> NS (NP f) (FunctorWrapTypeListOfLists g yss) -> NS (NP (f :.: g)) yss

157157 go SNil _ = error "NS must be non-empty." -- this shouldn't happen since an NS can't be empty

158158 go SCons (Z np) = Z $ npReCompose np

159159 go SCons (S nsTail) = S $ go sList nsTail

@@ -173,7 +173,7 @@ functorWrappedSListIsSList pf SCons = goCons (sList :: SList xs)

173173-- This is useful in cases where an efficient general solution exists for DMaps.

174174-- This can be done more simply for Applicative f but the efficiency will depend on

175175-- the particular functor and given function over 'DM.DMap'.

176−npSequenceViaDMap :: forall k (f :: * -> *) (g :: * -> *) (xs :: [*]). (Functor f, SListI xs, DM.GCompare k

176+npSequenceViaDMap :: forall k (f :: * -> *) (g :: * -> *) (xs :: [*]). (Functor f, SListI xs

177177 , k ~ TypeListTag (FunctorWrapTypeList g xs))

178178 =>(DM.DMap k f -> f (DM.DMap k Identity))->NP (f :.: g) xs -> f (NP g xs)

179179npSequenceViaDMap sequenceDMap =

src/Generics/SOP/Distribute.hs+4−5

@@ -34,7 +34,7 @@ import Generics.SOP.Dict (Dict, withDict)

3434-- | Turn a sum into a product with Maybes

3535expand :: forall (f :: [k] -> *) xs. (SListI xs) => NS f xs -> NP (Maybe :.: f) xs

3636expand ns = go sList (Just ns) where

37− go :: forall ys.SListI ys => SList ys -> Maybe (NS f ys) -> NP (Maybe :.: f) ys

37+ go :: forall ys. SList ys -> Maybe (NS f ys) -> NP (Maybe :.: f) ys

3838 go SNil _ = Nil

3939 go SCons mNS = case mNS of

4040 Nothing -> Comp Nothing :* go sList Nothing -- after Z

@@ -103,8 +103,9 @@ reconstructA :: (Functor h, Generic a) => NP (h :.: NP I) (Code a) -> NP (K (h a

103103reconstructA = hliftA (K . fmap (to . SOP) . unK) . hap wrappedInjections

104104

105105-- | Utility for turning a constraint into a POP (an NP of NP) of natural transformations at a given type.

106−functionPOPFromClass :: forall c f g xss. SListI2 xss

107− => Dict (All2 c) xss

106+functionPOPFromClass

107+ :: forall c f g xss

108+ . Dict (All2 c) xss

108109 -> (forall a. c a => f a -> g a)

109110 -> POP (f -.-> g) xss

110111functionPOPFromClass d f = withDict d $ hcpure (Proxy :: Proxy c) $ Fn f

@@ -116,5 +117,3 @@ functionPOPFromClass' fn =

116117 dict = all_POP hdicts

117118 in withDict dict $ hcpure (Proxy :: Proxy c) $ Fn fn

118119-}

119−

120−