Is it possible to have newtype-wrapped effects?

[ruifengx]

Here is my use case:

• All of the functions mentioned here writes binary data, so I intend to use Writer of byte string builder;
• However, the functions can be classified into several groups, and functions from different groups should not be used together;
• When I use transformers, the solution I use is to newtype wrap the monad for each group.

However, in effectful, newtype wrapping Eff seems very awkward, because I lose the extensibility etc. Therefore, I want to newtype-wrap the Writer effect instead, but I did not find a simple and straightforward way.

1. In Eff es, es has the nominal role, so I cannot simply coerce Eff (MyWriter : es) into Eff (Writer w : es).

2. For static dispatch (which I think is preferable here because Writer really does not have many useful interpretations, and Writer.Static.Local should suffice), when I have MyWriter :> es, I do not see a way to have Writer w :> es resolved, so I cannot delegate to Writer w.

3. For dynamic dispatch, what I have in mind is the following:

   • newtype MyWriter :: Effect = MyWriter (Writer Builder)
   • myTell s = send (MyWriter (Tell s))
   • and finally reinterpret MyWriter into Writer Builder

   But this is not ideal, because (a) the reinterpretation is linear in the number of operations, but in principle it can be O(1), and (b) this forces the use of dynamic dispatch, and I have no idea of the cost and whether I should worry about it in general.

I think a workaround is to relax Eff es and have es to be representational (the change would be on the Env data type), but I do not know enough of the internals to determine if this is viable for the library. If indeed representational is enough, I plan to work around this by using unsafeCoerce for now, before this relaxation is released. Other than the internal details, I think relaxing es to representational does not have real drawbacks, because to coerce, you'd still need the constructors of the effect to be in scope, and effects that need their internal states protected can avoid exporting the respective newtype constructors.

---

Edit: I think I know why it is nominal in the first place. The static effects relies on the DispatchOf type family to communicate its representation, and type families are nominal by their nature. I still think we can have a specialised coerce function for Eff, with some additional equality constraints, but with the proposed solution maybe it is not necessary anymore.

[mmhat]

Not sure, but for your use case (as I understand it) the Labeled effect might be useful:

{-# LANGUAGE GHC2021 #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE OverloadedStrings #-}

module ByteWriter where

import Prelude

import Data.ByteString.Builder (Builder)
import Effectful
import Effectful.Labeled (Labeled, labeled, runLabeled)
import Effectful.Writer.Static.Local (Writer, runWriter, tell)

type ByteWriter tag = Labeled tag (Writer Builder)

runByteWriter :: Eff (ByteWriter tag ': es) a -> Eff es (a, Builder)
runByteWriter = runLabeled runWriter

writeBytes :: forall tag es. (ByteWriter tag :> es) => Builder -> Eff es ()
writeBytes builder = labeled @tag @(Writer Builder) (tell builder)

writeSomeStuff :: IO ()
writeSomeStuff = do
    output <- runEff
        . runByteWriter @"group1"
        . runByteWriter @"group2"
        $ do
            writeBytes @"group1" "write"
            writeBytes @"group2" "some"
            writeBytes @"group1" "stuff"
    print output -- Output: (((),"some"),"writestuff")

If you are using GHC 9.10 then you can also use visible dependent quantification to get rid of AllowAmbiguousTypes:

{-# LANGUAGE GHC2021 #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RequiredTypeArguments #-}

module Labeled2 where

import Prelude

import Data.ByteString.Builder (Builder)
import Effectful
import Effectful.Labeled (Labeled, labeled, runLabeled)
import Effectful.Writer.Static.Local (Writer, runWriter, tell)

type ByteWriter tag = Labeled tag (Writer Builder)

runByteWriter :: forall tag -> Eff (ByteWriter tag ': es) a -> Eff es (a, Builder)
runByteWriter _tag = runLabeled runWriter

writeBytes :: forall tag -> (ByteWriter tag :> es) => Builder -> Eff es ()
writeBytes tag builder = labeled @tag @(Writer Builder) (tell builder)

writeSomeStuff :: IO ()
writeSomeStuff = do
    output <- runEff
        . runByteWriter "group1"
        . runByteWriter "group2"
        $ do
            writeBytes "group1" "write"
            writeBytes "group2" "some"
            writeBytes "group1" "stuff"
    print output -- Output: (((),"some"),"writestuff")

[ruifengx]

Ah, thanks. I do not really know how I missed this Labelled effect. It definitely solves my problem.

---

Edit: it internally uses unsafeCoerce, so it seems my instinct was not that incorrect after all. 😄

[arybczak]

I have no idea of the cost and whether I should worry about it in general.

You shouldn't 🙂

I think a workaround is to relax Eff es and have es to be representational

I see you've figured it out in the EDIT already, but just to confirm: this doesn't work because of StaticRep as you can wrap a static effect into a newtype and give it a completely different StaticRep instance.