Example of monad transformer that doesn't need IO

[flip111]

Following the guide. Given this monad monad transformer that does no IO and has an internal state of [Unique].

In case the Eff monad doesn't provide a specific instance out of the box, it can be supplied via an effect. As an example see how the instance of MonadResource for Eff is implemented in the resourcet-effectful package.

The types are doable.

data EffUnique :: Effect

type instance DispatchOf EffUnique = Static NoSideEffects
newtype instance StaticRep EffUnique = EffUnique [Unique]

but then for the run function i'm lost. Looking at runResource for inspiration. Some questions/remarks:

1. mask i probably don't need it since no IO is needed
2. consEnv. Not sure what this is about, i can make a guess but i couldn't find thorough documentation. so make sure you understand what you're doing how to make sure?
3. unEff uses IO. What alternative for unEff should be used?

Library looks interesting, it's a bit steep learning curve on a first try.

[evanrelf]

The Unique effect you want is basically just a domain-specific State effect. Here's a basic implementation:

#!/usr/bin/env nix-shell
#!nix-shell -i runghc -p "ghc.withPackages (p: with p; [ effectful-core effectful-plugin ])"

{-# LANGUAGE BlockArguments #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GHC2021 #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TypeFamilies #-}

{-# OPTIONS_GHC -fplugin=Effectful.Plugin #-}

module Main (main) where

import Data.Kind (Type)
import Effectful
import Effectful.Dispatch.Static

data Unique (u :: Type) :: Effect

type instance DispatchOf (Unique u) = Static NoSideEffects

newtype instance StaticRep (Unique u) = Unique [u]

runUnique :: [u] -> Eff (Unique u : es) a -> Eff es a
runUnique us = evalStaticRep (Unique us)

fresh :: Unique u :> es => Eff es u
fresh = stateStaticRep \case
  Unique [] -> error "fresh: empty list"
  Unique (u : us) -> (u, Unique us)

main :: IO ()
main = do
  runEff . runUnique [1 :: Int .. 3] $ do
    u1 <- fresh
    liftIO $ print u1
    u2 <- fresh
    liftIO $ print u2
    u3 <- fresh
    liftIO $ print u3
    u4 <- fresh
    liftIO $ print u4

-- $ ./unique.hs
-- 1
-- 2
-- 3
-- unique.hs: fresh: empty list
-- CallStack (from HasCallStack):
--   error, called at unique.hs:29:16 in main:Main

[arybczak]

You can do what @evanrelf suggested (seems you also need instances of MonadUnique and MonadCheckpoint). It's sufficient if there's only going to be one way to use UniqueMonad/CheckpointMonad.

If there can be multiple implementations, then this case seems to belong more in this category. Although these cases overlap a little, so I can see the confusion. I probably should improve the description a bit.

If you go this route, the linked example in the docs should be pretty clear. You need to create a dynamic effect and a handler that reinterprets State.

[flip111]

Hi @evanrelf thanks for the code example. I kind of understand it on it's own. Though it still confuses me in the larger context of my question because there is no type that is the same like the code i want to make compatible. For example.

Library code

type Unique = Int
newtype UniqueMonadT m a = UMT { unUMT :: [Unique] -> m (a, [Unique]) }

Example code

Unique [u]

So if i try to make that, i get something like u ~ Unique and Unique ~ UniqueMonadT or something like that. Maybe i can work that out because i think your example has the shape that i will be needing and it needs to be adapted.

But where i am really getting lost is where fresh seems to be a re-implementation of freshUnique without calling out the the original function. The code still needs access to the original freshUnique function in other places.

Was the example intended as reimplementation of the library or as an example of how to make it compatible with the library? I don't want to change library code at this point in time. And in general it is good to know how to use effectful with library code that is written by someone else or you otherwise have no control over.

---

@arybczak thanks for your answer.

If there can be multiple implementations

What do you mean? Implementation of what part exactly? I hope i only need to write "adapter code" from 1 monad transformer to effectful once. Not sure why would one want to have multiple implementations.

You need to create a dynamic effect and a handler that reinterprets State.

I like to have static dispatch because i believe it is more performant. I do understand what dynamic dispatch is but at this moment i can not think of an example why i would want to have dynamic dispatch. i.e. a feature that is only possible with dynamic dispatch.

About the Dynamic approach in the example

  runDummyRNG :: Eff (RNG : es) a -> Eff es a
  runDummyRNG = interpret $ \_ -> \case
    RandomInt -> pure 55

instead of pure 55 how to call the randomInt of an already existing implementation? or in my case how can this instance of freshUnique be called? The constraint for MonadRNG is no longer available. It is still available at this point though

  instance RNG :> es => MonadRNG (Eff es) where
    randomInt = send RandomInt

[evanrelf]

Was the example intended as reimplementation of the library or as an example of how to make it compatible with the library?

Ah my bad. I re-implemented the effect from scratch. I didn't realize you wanted to wrap the existing code in effectful.

[evanrelf]

I like to have static dispatch because i believe it is more performant.

Unless you have an extreme performance requirement, you're probably fine using dynamic dispatch.

at this moment i can not think of an example why i would want to have dynamic dispatch. i.e. a feature that is only possible with dynamic dispatch.

I could imagine an alternative way of providing unique values. Instead of providing a list upfront:

runUnique :: [u] -> Eff (Unique u : es) a -> Eff es a
runUnique us = {- ... -}

you could provide an action that gets the unique value on demand:

runUnique :: Eff es u -> Eff (Unique u : es) a -> Eff es a
runUnique getU = {- ... -}

[flip111]

@evanrelf well thanks anyway the code was inspirational. Yes i was looking for Integration with existing libraries. Do you know of a good example of integration with an existing library other than an example with IO such as resourceT?

[arybczak]

Have a look at hpqtypes-effectful, crypto-rng-effectful, monad-time-effectful and others here.