Have we tried to use implicit parameters for the handles?

[jf-travolta]

Hi,

I tried little bit the library and experiment with implicit parameters, the good thing about implicit parameters are:

• They are expressed in constraints, so we can combine then in composed constraints
• They do not need explicit order, as they are binding by name
• They are removed from the function signature, so that everything is little bit clear

I was playing around with this idea and come with something that works:

module Network.TestingB
(testing, testing2)
where

import Bluefin.Eff
import Bluefin.Exception
import Bluefin.IO

type HasIO ioe es = (ioe :> es, ?ioe2 :: IOE ioe)

type HasException ext ex es = (ex :> es, ?ex2 :: Exception ext ex)

type HasAll ext ex ioe es = (HasIO ioe es, HasException ext ex es)

effIO' :: (HasIO ioe es) => IO a -> Eff es a
effIO' = effIO ?ioe2

throw' :: (HasException e ex es) => e -> Eff es a
throw' = throw ?ex2

testing :: (ioe :> es, exs :> es) => IOE ioe -> Exception String exs -> Eff es ()
testing io exception = do
    effIO io $ putStrLn "Hello"
    throw exception "testing"

testing2 :: (HasAll String ex ioe es) => Eff es ()
testing2 = do
    effIO' $ putStrLn "Hello"
    throw' "testing"


testing3 :: (HasIO ioe es, HasException String ex es) => Eff es ()
testing3 = do
    effIO' $ putStrLn "Hello"
    throw' "testing"



running :: IO ()
running = do
  result <- runEff $ \ (io :: IOE ioType) -> try $ \ (ex :: Exception String exType) -> 
    let 
        ?ioe2 = io
        ?ex2 = ex 
    in testing2 @exType @ioType
  putStrLn (show result)

The main issue here is that I cannot generalise the conversion from explicit to implicit (I am not an expert in type system of haskell). Every time I try to do something like:

try' :: HasException exn ex es =>  Eff (ex :& es) a -> Eff es (Either exn a)
try' f = try $ \ (ex :: Exception exn exType) -> go ex 
    where
        go ex = let ?ex2 = ex in f

then compiler complains

   • Couldn't match type ‘e’ with ‘ex’
      Expected: Eff (e :& es) a
        Actual: Eff (ex :& es) a
      ‘e’ is a rigid type variable bound by
        a type expected by the context:
          forall (e :: Effects). Exception exn e -> Eff (e :& es) a
...

Not sure if that would be possible to solve or is a limitation in Haskell

[tomjaguarpaw]

It would be nice to get something like this working, but it's not a high priority for me personally. There is substantial discussion already at: #32

[arybczak]

Btw, isn't "bluefin with implicit parameters" basically a variant of effectful? Or is there something I'm missing 🤔

I thought the whole point of bluefin is explicit passing of effects.

[tomjaguarpaw]

isn't "bluefin with implicit parameters" basically a variant of effectful?

Bluefin effects passed as implicit parameters are still labelled. Maybe that's equivalent to Effectful.Labeled? I'm not sure; I haven't used either in practice.

Beyond that, effectful has the convenience that not only are effects passed implicitly but they are centrally tracked as a form of "thread-local" storage, which Bluefin-with-implicit-parameters doesn't benefit from.

I thought the whole point of bluefin is explicit passing of effects.

I suppose it's to be able to explicitly pass effects. Perhaps combining that with implicit effects could be useful. It's not something I want personally.