How to implement early return in effectful?

[kedashoe]

I've attempted for a while myself but haven't gotten anywhere. Something like..?

type ExceptA m a = (Monad m) => ExceptT a m a

data EarlyReturn :: Effect where
  DoReturnEarly :: ExceptA m a -> EarlyReturn m a

type instance DispatchOf EarlyReturn = Dynamic

earlyReturn
  :: (HasCallStack, EarlyReturn :> es)
  => ExceptA m a
  -> Eff es a
earlyReturn action = send (DoReturnEarly action)

runEarlyReturn :: Eff (EarlyReturn : es) a -> Eff es a
runEarlyReturn = interpret $ \_ -> \case
  DoReturnEarly action -> do
    x <- runExceptT action
    case x of
      Left y  -> pure y
      Right z -> pure z

Any help would be greatly appreciated. Thank you!

[ocharles]

Early return is best implemented as an exception in effectful. We do early return by just doing:

data EarlyReturn = EarlyReturn

earlyReturn :: Error EarlyReturn :> es => Eff es ()
earlyReturn = throwError EarlyReturn

runEarlyReturn :: Eff (EarlyReturn : es) () -> Eff es (Maybe a)
runEarlyReturn = fmap (either (const Nothing) Just) . runErrorNoCallStack @EarlyReturn

I think effectful would benefit from packaging this up into effectful-core

[arybczak]

You should piggyback on the Error effect, since EarlyReturn is Error without CatchError:

import Effectful
import Effectful.Dispatch.Dynamic
import Effectful.Error.Static

data EarlyReturn r :: Effect where
  ReturnWith :: r -> EarlyReturn r m a

type instance DispatchOf (EarlyReturn r) = Dynamic

returnWith
  :: (HasCallStack, EarlyReturn r :> es)
  => r
  -> Eff es a
returnWith = send . ReturnWith

runEarlyReturn :: Show r => Eff (EarlyReturn r : es) a -> Eff es (Either (CallStack, r) a)
runEarlyReturn = reinterpret_ runError $ \case
  ReturnWith r -> throwError r

You can also do runErrorNoCallStack if you don't want a call stack in the result (or throwError_ if you don't want to impose the Show constraint).

[kedashoe]

Thank you for the quick replies! Will play around with it

[kedashoe]

Is this type

runEarlyReturn :: Show r => Eff (EarlyReturn r : es) a -> Eff es (Either (CallStack, r) a)

maybe problematic? Specifically the Either (CallStack, r) a in the return type. It seems to propagate to the overall type of our run pipeline, ie in main if we have runEff . runX . runY . runEarlyReturn we get an Either coming out.

Regardless of that (which may not be a big issue, is there a simple way around it?), I think it would be preferable to have a type runEarlyReturn :: Eff (EarlyReturn : es) a -> Eff es a. Just the plain a is nice. Often it is actually what we want, returnWith x for that x to have the same type as the "normal return" at the end of our function. It also does not preclude using Either or Maybe, we can still returnWith $ Left "foo" or returnWith Nothing and later have a Right 10 or Just 5.

I've got a version which type checks now, but seems there is still an issue as the call site is giving me an error I don't well understand. The effect:

import Control.Monad.Trans.Except (ExceptT (..), runExceptT, throwE)

data EarlyReturn :: Effect where
  ReturnWith :: ExceptT a m a -> EarlyReturn m a

type instance DispatchOf EarlyReturn = Dynamic

returnWith
  :: forall a es
   . (HasCallStack, EarlyReturn :> es)
  => a
  -> Eff es a
returnWith a = send (ReturnWith (throwE a))

runEarlyReturn :: Eff (EarlyReturn : es) a -> Eff es a
runEarlyReturn = interpret $ \env -> \case
  ReturnWith action -> localSeqUnlift env $ \unlift -> do
    fmap (either id id) (unlift (runExceptT action))

Attempt to use it:

earlyReturnTest
  :: forall es
   . (HasCallStack, EarlyReturn :> es)
  => Int
  -> Eff es Bool
earlyReturnTest n = do
  when (n < 10) $
    returnWith True
  pure False

Error:

• Couldn't match expected type ‘()’ with actual type ‘Bool’
• In the first argument of ‘returnWith’, namely ‘True’

[ocharles]

To do this you just need to use throwError with an a. The idea is your code eiterh produces an a as the end result or throws an a. This will give you an Either a a, which you can collapse to just a.

[kedashoe]

There is a throwE in the definition of returnWith, returnWith a = send (ReturnWith (throwE a)). I can move some types around to instead do returnWith (throwError True) at the call site but it results in a similar error and the user experience is not as nice.

I feel like the expected type ‘()’ referenced in the compiler error message is the problem? I can't figure out why that is expected though.