difficulty with a polymorphic effect handler

[mccraigmccraig]

i've been failing to get a handler for a polymorphic effect to compile...

here's some elided code, with just the dependencies of the failing function (full code here )

(the code is a 🚧 work-in-progress 🚧 attempt at a functional-core message-processing pattern, with introspection logging and recovery)

module elided

import std/core/list

pub alias stringsrc = () -> string

pub effect logger
  // open a step-log
  fun log-enter(name: string, input-ser: stringsrc) : ()
  // close a step log successfully
  fun log-complete(output-ser: stringsrc) : ()
  // close a step log with an error
  fun log-error(error-ser: stringsrc) : ()

pub value struct serde<a>
  ser: (a) -> string
  deser: (string) -> either<string,a>

pub alias pure-step<i,o> = (i) -> <pure,logger> o
pub alias effectful-step<i,o,e> = (i) -> <pure,logger|e> o

pub type step<i,o,e>
  Pure(pname: string, 
    pstep: pure-step<i,o>, 
    ?pi/serde: serde<i>, 
    ?po/serde: serde<o>)
  Effectful(fname: string, 
    fstep: effectful-step<i,o,e>, 
    ?fi/serde: serde<i>, 
    ?fo/serde: serde<o>)

pub fun run-step<i,o,e>(s: step<i,o,e>, i: i): <pure,logger|e> o
  match s
    Pure(nm, f, iserde, oserde) -> 
      log-enter(nm, {iserde.ser()(i)})
      val o = f(i)
      log-complete({oserde.ser()(o)})
      o
    Effectful(nm, f, iserde, oserde) -> 
      log-enter(nm, {iserde.ser()(i)})
      val o = f(i)
      log-complete({oserde.ser()(o)})
      o

// elided chain structure ... to illustrate problem
pub alias chain<i,o,e> = step<i,o,e>

// run a chain of steps. blows up stack if chain too long
pub fun run-chain(c: chain<i,o,e>, i: i): <pure,logger|e> o
  run-step(c, i)

pub struct computation<i,d,o,v,e>
  name: string // the name of the computation, and also the name of the pure step
  input-chain: chain<i,d,e>
  pure: pure-step<d,o>
  output-chain: chain<o,v,e>

// allows control of input-gathering and output-performing actions - 
// perhaps data is read directly from a serialized message, or written 
// to a kafka topic rather than performed immediately
pub effect computation-io<i,d,o,v,e>
  ctl inputs-fx(c: computation<i,d,o,v,e>, i: i) : d
  ctl outputs-fx(c: computation<i,d,o,v,e>, o: o) : v

// handle computation io by running chains
pub fun run-chain-io-handler<i,d,o,v,e>(action: () -> <computation-io<i,d,o,v,e>,pure,logger|e> v): <pure,logger|e> v
  with handler 
    ctl inputs-fx(c, i)
      run-chain(c.input-chain, i)
    ctl outputs-fx(c, o)
      run-chain(c.output-chain, o)
  action()

i get an error against the action() term on the last line, which i can't make sense of:

abstract types do not match
context        :   with handler 
                 ...
                   action()
term           :   action()
inferred effect: <computation-io<$a,$b,$c,$d,$e>,div,exn,logger|$e>
expected effect: <computation-io<$a,$d,_a1,$d,_e1>,div,exn,logger|_e1>
hint           : an higher-rank type escapes its scope?

as far as i can see from the error the expected effect type does not match what should be derived from the computation-io effect operator signatures, and after much playing around i'm still unable to see where i've gone wrong

any help greatly appreciated!

[TimWhiting]

I haven't looked at it too closely, but the following two alternatives type-check fine:

Most likely you are trying to resume after running this part of the chain, but as written your operations do not resume. You can either add the resume, or swap ctl and resume for a fun operation since it is tail resumptive. Note that you can use the more restrictive fun operation here even if you want to keep the effect itself more flexible by allowing any ctl operation.

pub fun run-chain-io-handler<i,d,o,v,e>(action: () -> <computation-io<i,d,o,v,e>,pure,logger|e> v): <pure,logger|e> v
  with handler 
    ctl inputs-fx(c, i)
      resume(run-chain(c.input-chain, i))
    ctl outputs-fx(c, o)
      resume(run-chain(c.output-chain, o))
  action()

Or if you are trying to not resume, and just want to jump out of the computation and return from the handler here, the issue is that inputs-fx returns something of type d and ouputs-fx returns something of type v so the two need to be the same in the action.
This is what the inferred / expected effect is trying to tell you (you have b and d, where it has d and d). The easiest way to fix these sorts of issues sometimes is to remove all type annotations from the function you are having trouble annotating, and if it type checks fine then hover over the function name and see what type inference has given it. (This is how I found the issue).

pub fun run-chain-io-handler<i,d,o,e>(action: () -> <computation-io<i,d,o,d,e>,pure,logger|e> d): <pure,logger|e> d
  with handler 
    ctl inputs-fx(c, i)
      run-chain(c.input-chain, i)
    ctl outputs-fx(c, o)
      run-chain(c.output-chain, o)
  action()

[mccraigmccraig]

doh! now i get it - i've only been using fun handlers until now, but wanted a ctl handler here, and of course they behave differently - but my brain was refusing to see it!

thanks @TimWhiting !