47b2ec6 · typeable/ether

git.iko.soy/typeable/ether

on master help sign in

Ambiguous default for MonadWriter

47b2ec6Index Int10 years ago

ether.cabal−1

compare with master

unifiedsplit

@@ -55,7 +55,6 @@ library

55 Control.Monad.Ether.Implicit.State.Strict

56 Control.Monad.Ether.Implicit.Except

57 Control.Monad.Ether.Ambiguous

58− Control.Monad.Ether.Ambiguous.Writer

59 Control.Monad.Ether.Ambiguous.State

58 Control.Monad.Ether.Ambiguous.State

60 Control.Monad.Ether.Ambiguous.State.Lazy

59 Control.Monad.Ether.Ambiguous.State.Lazy

61 Control.Monad.Ether.Ambiguous.State.Strict

60 Control.Monad.Ether.Ambiguous.State.Strict

src/Control/Monad/Ether/Ambiguous.hs+1−1

@@ -7,7 +7,7 @@ module Control.Monad.Ether.Ambiguous (module X) where

7import Control.Monad as X

8import Control.Monad.Fix as X

9import Control.Monad.Ether.Reader as X

10−import Control.Monad.Ether.Ambiguous.Writer as X

10+import Control.Monad.Ether.Writer as X

11import Control.Monad.Ether.Ambiguous.State as X

12import Control.Monad.Ether.Ambiguous.Except as X

13import Control.Monad.Trans.Ether.Dispatch as X

src/Control/Monad/Ether/Ambiguous/Writer.hsdeleted−74

@@ -1,74 +0,0 @@

1−{-# LANGUAGE AllowAmbiguousTypes #-}

2−{-# LANGUAGE ScopedTypeVariables #-}

3−{-# LANGUAGE MagicHash #-}

4−

5−-- | See "Control.Monad.Ether.Writer".

6−

7−module Control.Monad.Ether.Ambiguous.Writer

8− (

9− -- * MonadWriter class

10− MonadWriter

11− , writer

12− , tell

13− , listen

14− , pass

15− , listens

16− , censor

17− -- * The Writer monad

18− , Writer

19− , runWriter

20− , execWriter

21− -- * The WriterT monad transformer

22− , WriterT

23− , writerT

24− , runWriterT

25− , execWriterT

26− ) where

27−

28−import GHC.Prim (Proxy#, proxy#)

29−import Control.Monad.Ether.Writer (MonadWriter, WriterT, Writer)

30−import qualified Control.Monad.Ether.Writer as Explicit

31−

32−-- | See 'Control.Monad.Ether.Writer.writer'.

33−writer :: forall tag w m a . MonadWriter tag w m => (a, w) -> m a

34−writer = Explicit.writer (proxy# :: Proxy# tag)

35−

36−-- | See 'Control.Monad.Ether.Writer.tell'.

37−tell :: forall tag w m . MonadWriter tag w m => w -> m ()

38−tell = Explicit.tell (proxy# :: Proxy# tag)

39−

40−-- | See 'Control.Monad.Ether.Writer.listen'.

41−listen :: forall tag w m a . MonadWriter tag w m => m a -> m (a, w)

42−listen = Explicit.listen (proxy# :: Proxy# tag)

43−

44−-- | See 'Control.Monad.Ether.Writer.pass'.

45−pass :: forall tag w m a . MonadWriter tag w m => m (a, w -> w) -> m a

46−pass = Explicit.pass (proxy# :: Proxy# tag)

47−

48−-- | See 'Control.Monad.Ether.Writer.listens'.

49−listens :: forall tag w m a b . MonadWriter tag w m => (w -> b) -> m a -> m (a, b)

50−listens = Explicit.listens (proxy# :: Proxy# tag)

51−

52−-- | See 'Control.Monad.Ether.Writer.censor'.

53−censor :: forall tag w m a . MonadWriter tag w m => (w -> w) -> m a -> m a

54−censor = Explicit.censor (proxy# :: Proxy# tag)

55−

56−-- | See 'Control.Monad.Ether.Writer.runWriter'.

57−runWriter :: forall tag w a . Writer tag w a -> (a, w)

58−runWriter = Explicit.runWriter proxy#

59−

60−-- | See 'Control.Monad.Ether.Writer.execWriter'.

61−execWriter :: forall tag w a . Writer tag w a -> w

62−execWriter = Explicit.execWriter proxy#

63−

64−-- | See 'Control.Monad.Ether.Writer.writerT'.

65−writerT :: forall tag w m a . m (a, w) -> WriterT tag w m a

66−writerT = Explicit.writerT proxy#

67−

68−-- | See 'Control.Monad.Ether.Writer.runWriterT'.

69−runWriterT :: forall tag w m a . WriterT tag w m a -> m (a, w)

70−runWriterT = Explicit.runWriterT proxy#

71−

72−-- | See 'Control.Monad.Ether.Writer.execWriterT'.

73−execWriterT :: forall tag w m a . Monad m => WriterT tag w m a -> m w

74−execWriterT = Explicit.execWriterT proxy#

src/Control/Monad/Ether/Implicit/Writer.hs+1−1

@@ -25,7 +25,7 @@ module Control.Monad.Ether.Implicit.Writer

25 , execWriterT

26 ) where

28−import qualified Control.Monad.Ether.Ambiguous.Writer as A

28+import qualified Control.Monad.Ether.Writer as A

30-- | See 'Control.Monad.Ether.Writer.MonadWriter'.

31type MonadWriter w = A.MonadWriter w w

src/Control/Monad/Ether/Writer.hs+43−2

@@ -1,10 +1,18 @@

1+{-# LANGUAGE AllowAmbiguousTypes #-}

2+{-# LANGUAGE TypeApplications #-}

3+{-# LANGUAGE ScopedTypeVariables #-}

4+{-# LANGUAGE MagicHash #-}

2-- | See "Control.Monad.Writer".

6-- | See "Control.Monad.Writer".

4module Control.Monad.Ether.Writer

8module Control.Monad.Ether.Writer

5 (

9 (

6 -- * MonadWriter class

10 -- * MonadWriter class

7− MonadWriter(..)

11+ MonadWriter

12+ , writer

13+ , tell

14+ , listen

15+ , pass

8 , listens

16 , listens

9 , censor

17 , censor

10 -- * The Writer monad

18 -- * The Writer monad

@@ -18,5 +26,38 @@ module Control.Monad.Ether.Writer

18 , execWriterT

26 , execWriterT

19 ) where

27 ) where

29+import GHC.Prim (Proxy#, proxy#)

21−import Control.Monad.Ether.Writer.Class

30+import Control.Monad.Ether.Writer.Class (MonadWriter)

31+import qualified Control.Monad.Ether.Writer.Class as C

22import Control.Monad.Trans.Ether.Writer hiding (writer, tell, listen, pass)

32import Control.Monad.Trans.Ether.Writer hiding (writer, tell, listen, pass)

33+

34+-- | Embed a simple writer action.

35+writer :: forall tag w m a . MonadWriter tag w m => (a, w) -> m a

36+writer = C.writer (proxy# :: Proxy# tag)

37+

38+-- | Append a value to the accumulator within the monad.

39+tell :: forall tag w m . MonadWriter tag w m => w -> m ()

40+tell = C.tell (proxy# :: Proxy# tag)

41+

42+-- | Execute an action and add its accumulator

43+-- to the value of the computation.

44+listen :: forall tag w m a . MonadWriter tag w m => m a -> m (a, w)

45+listen = C.listen (proxy# :: Proxy# tag)

46+

47+-- | Execute an action which returns a value and a function,

48+-- and return the value, applying the function to the accumulator.

49+pass :: forall tag w m a . MonadWriter tag w m => m (a, w -> w) -> m a

50+pass = C.pass (proxy# :: Proxy# tag)

51+

52+-- | Execute an action and add the result of applying the given function to

53+-- its accumulator to the value of the computation.

54+listens :: forall tag w m a b . MonadWriter tag w m => (w -> b) -> m a -> m (a, b)

55+listens f m = do

56+ ~(a, w) <- listen @tag m

57+ return (a, f w)

58+

59+-- | Execute an action and apply a function to its accumulator.

60+censor :: forall tag w m a . MonadWriter tag w m => (w -> w) -> m a -> m a

61+censor f m = pass @tag $ do

62+ a <- m

63+ return (a, f)

src/Control/Monad/Ether/Writer/Class.hs+8−21

@@ -4,15 +4,15 @@

4{-# LANGUAGE FunctionalDependencies #-}

5{-# LANGUAGE TypeFamilies #-}

6{-# LANGUAGE PolyKinds #-}

7+{-# LANGUAGE TypeApplications #-}

8+{-# LANGUAGE ScopedTypeVariables #-}

7{-# LANGUAGE MagicHash #-}

9{-# LANGUAGE MagicHash #-}

9-- | See "Control.Monad.Writer.Class".

11-- | See "Control.Monad.Writer.Class".

11module Control.Monad.Ether.Writer.Class

13module Control.Monad.Ether.Writer.Class

12− ( MonadWriter(..)

14+ ( MonadWriter(..)

13− , listens

14− , censor

15− ) where

15+ ) where

17import GHC.Prim (Proxy#)

18import qualified Control.Monad.Trans.Ether.Writer as W

@@ -42,24 +42,11 @@ class (Monoid w, Monad m) => MonadWriter tag w m | m tag -> w where

42 -- and return the value, applying the function to the accumulator.

43 pass :: Proxy# tag -> m (a, w -> w) -> m a

45−-- | Execute an action and add the result of applying the given function to

46−-- its accumulator to the value of the computation.

47−listens :: MonadWriter tag w m => Proxy# tag -> (w -> b) -> m a -> m (a, b)

48−listens t f m = do

49− ~(a, w) <- listen t m

50− return (a, f w)

51−

52−-- | Execute an action and apply a function to its accumulator.

53−censor :: MonadWriter tag w m => Proxy# tag -> (w -> w) -> m a -> m a

54−censor t f m = pass t $ do

55− a <- m

56− return (a, f)

57−

58instance (Monoid w, Monad m, w ~ w') => MonadWriter tag w (W.WriterT tag w' m) where

45instance (Monoid w, Monad m, w ~ w') => MonadWriter tag w (W.WriterT tag w' m) where

59− writer = W.writer

46+ writer _ = W.writer @tag

60− tell = W.tell

47+ tell _ = W.tell @tag

61− listen = W.listen

48+ listen _ = W.listen @tag

62− pass = W.pass

49+ pass _ = W.pass @tag

64instance {-# OVERLAPPABLE #-}

51instance {-# OVERLAPPABLE #-}

65 ( Lift.LiftListen t

52 ( Lift.LiftListen t

src/Control/Monad/Trans/Ether/Writer.hs+21−20

@@ -6,7 +6,9 @@

6{-# LANGUAGE DataKinds #-}

7{-# LANGUAGE PolyKinds #-}

8{-# LANGUAGE GeneralizedNewtypeDeriving #-}

9−{-# LANGUAGE MagicHash #-}

9+{-# LANGUAGE AllowAmbiguousTypes #-}

10+{-# LANGUAGE TypeApplications #-}

11+{-# LANGUAGE ScopedTypeVariables #-}

11-- | See "Control.Monad.Trans.Writer".

13-- | See "Control.Monad.Trans.Writer".

@@ -28,7 +30,6 @@ module Control.Monad.Trans.Ether.Writer

28 , pass

30 , pass

29 ) where

31 ) where

31−import GHC.Prim (Proxy#)

32import Data.Functor.Identity (Identity(..))

33import Data.Functor.Identity (Identity(..))

33import qualified Control.Monad.Trans.Writer.Lazy as Trans

34import qualified Control.Monad.Trans.Writer.Lazy as Trans

34import Control.Monad.Trans.Ether.Tagged

35import Control.Monad.Trans.Ether.Tagged

@@ -48,43 +49,43 @@ type Writer tag w = WriterT tag w Identity

48type WriterT tag w = TaggedTrans tag (Trans.WriterT w)

49type WriterT tag w = TaggedTrans tag (Trans.WriterT w)

50-- | Constructor for computations in the writer monad transformer.

51-- | Constructor for computations in the writer monad transformer.

51−writerT :: Proxy# tag -> m (a, w) -> WriterT tag w m a

52+writerT :: forall tag w m a . m (a, w) -> WriterT tag w m a

52−writerT _ = pack . Trans.WriterT

53+writerT = pack . Trans.WriterT

54-- | Constructor for computations in the writer monad

55-- | Constructor for computations in the writer monad

55-- (the inverse of 'runWriter').

56-- (the inverse of 'runWriter').

56−writer :: Monad m => Proxy# tag -> (a, w) -> WriterT tag w m a

57+writer :: forall tag w m a . Monad m => (a, w) -> WriterT tag w m a

57−writer _ = pack . Trans.writer

58+writer = pack . Trans.writer

59-- | Runs a 'WriterT' and returns both the normal value

60-- | Runs a 'WriterT' and returns both the normal value

60-- and the final accumulator.

61-- and the final accumulator.

61−runWriterT :: Proxy# tag -> WriterT tag w m a -> m (a, w)

62+runWriterT :: forall tag w m a . WriterT tag w m a -> m (a, w)

62−runWriterT _ = Trans.runWriterT . unpack

63+runWriterT = Trans.runWriterT . unpack

64-- | Runs a 'Writer' and returns both the normal value

65-- | Runs a 'Writer' and returns both the normal value

65-- and the final accumulator.

66-- and the final accumulator.

66−runWriter :: Proxy# tag -> Writer tag w a -> (a, w)

67+runWriter :: forall tag w a . Writer tag w a -> (a, w)

67−runWriter _ = Trans.runWriter . unpack

68+runWriter = Trans.runWriter . unpack

69-- | Runs a 'WriterT' and returns the final accumulator,

70-- | Runs a 'WriterT' and returns the final accumulator,

70-- discarding the normal value.

71-- discarding the normal value.

71−execWriterT :: Monad m => Proxy# tag -> WriterT tag w m a -> m w

72+execWriterT :: forall tag w m a . Monad m => WriterT tag w m a -> m w

72−execWriterT _ = Trans.execWriterT . unpack

73+execWriterT = Trans.execWriterT . unpack

74-- | Runs a 'Writer' and returns the final accumulator,

75-- | Runs a 'Writer' and returns the final accumulator,

75-- discarding the normal value.

76-- discarding the normal value.

76−execWriter :: Proxy# tag -> Writer tag w a -> w

77+execWriter :: forall tag w a . Writer tag w a -> w

77−execWriter _ = Trans.execWriter . unpack

78+execWriter = Trans.execWriter . unpack

79-- | Appends a value to the accumulator within the monad.

80-- | Appends a value to the accumulator within the monad.

80−tell :: Monad m => Proxy# tag -> w -> WriterT tag w m ()

81+tell :: forall tag w m . Monad m => w -> WriterT tag w m ()

81−tell t w = writer t ((), w)

82+tell w = writer @tag ((), w)

83-- | Executes an action and adds its accumulator to the value of the computation.

84-- | Executes an action and adds its accumulator to the value of the computation.

84−listen :: Monad m => Proxy# tag -> WriterT tag w m a -> WriterT tag w m (a, w)

85+listen :: forall tag w m a . Monad m => WriterT tag w m a -> WriterT tag w m (a, w)

85−listen _ = pack . Trans.listen . unpack

86+listen = pack . Trans.listen . unpack

87-- | Executes an action which returns a value and a function, and returns the

88-- | Executes an action which returns a value and a function, and returns the

88-- value, applying the function to the accumulator.

89-- value, applying the function to the accumulator.

89−pass :: Monad m => Proxy# tag -> WriterT tag w m (a, w -> w) -> WriterT tag w m a

90+pass :: forall tag w m a . Monad m => WriterT tag w m (a, w -> w) -> WriterT tag w m a

90−pass _ = pack . Trans.pass . unpack

91+pass = pack . Trans.pass . unpack