Performing effects inside handlers? Unclear type error #660

FayCarsons · 2025-01-15T23:27:38Z

FayCarsons
Jan 15, 2025

I'm trying to write a small reactive signal library. Here is the core of it:

import set
import std/core/unsafe
import html

pub value struct signal<a, h>
  deps:  ref<h, set<(a) -> total ()>>
  inner: ref<h, a>

effect state<a,h>
  ctl get( self: signal<a,h>): a
  ctl set( self: signal<a, h>, value: a): ()

pub fun with-context(action: () -> <state<a, h>> ())
  with 
    ctl get(s)
      with unsafe-total
      s.deps.modify fn(d)
        d.insert(resume)
      !s.inner
    ctl set(s, value)
      with unsafe-total
      s.inner.set(value)
      (!s.deps).set/foreach fn(dep)
        dep(!s.inner)
  action()

pub fun signal/create(inner: a): <alloc<h>|e> signal<a,h>
  Signal(ref(set/empty()), ref(inner))
  
fun example()
  val a-signal = signal/create("foo")
  Div(
    [("style", "color: red;")], 
    [P([], a-signal.get())]
  )

The idea being:

You wrap the root of your program in with-context
Every time you access a signal by performing the get effect, the continuation for that call is inserted into that signal's dependencies
Every time that signal's inner value is mutated, it calls its dependencies' continuations forcing a re-render

I'm running into a couple of problems:

I can't figure out how to mutate the fields of the signal from inside a handler without using unsafe-total, is there a workaround for this pattern? I've had similar issues implementing a basic writer effect a la Haskell's writer monad
Currently, my program does not type check because of some clash in effect types, the specific issue being:

type error: effects do not match
  context        :   with 
                   ...
                     action()
  term           :   action()
  inferred effect: <state<$a,$h>|_e>
  expected effect: (state<(),_h1>)

Any advice?

TimWhiting · 2025-01-16T03:55:30Z

TimWhiting
Jan 16, 2025
Collaborator

import std/core/unsafe

alias set = list

pub value struct signal<a,h>
  deps:  ref<h, set<(a) -> <div,st<h>> ()>>
  inner: ref<h, a>

effect state<a,h>
  ctl get( self: signal<a,h>): a
  ctl set( self: signal<a,h>, value: a): ()

pub fun with-context(action: () -> <state<a, h>,div,st<h>> ()): <div,st<h>> ()
  with handler
    ctl get(s)
      s.deps.modify fn(d)
        Cons(resume, d)
      resume(!s.inner)
    ctl set(s, value)
      s.inner.set(value)
      (!s.deps).foreach fn(dep)
        dep(!s.inner)
  action()

pub fun signal/create(inner: a): <alloc<h>|e> signal<a,h>
  Signal(ref([]), ref(inner))
  
type html
  Div(attrs: list<(string, string)>, children: list<html>)
  P(attrs: list<(string, string)>, info: string)

fun html/show(html: html): div string
  match html
    Div(attrs, children) -> 
      "<div " ++ attrs.map(fn((k, v)) k ++ "=\"" ++ v ++ "\"").join(" ") ++ ">" ++ children.map(show).join("") ++ "</div>"
    P(attrs, info) -> 
      "<p " ++ attrs.map(fn((k, v)) k ++ "=\"" ++ v ++ "\"").join(" ") ++ ">" ++ info ++ "</p>"

fun example()
  with with-context
  val a-signal = signal/create("foo")
  Div(
    [("style", "color: red;")], 
    [P([], a-signal.get())]
  ).show.trace
  ()

First of all, I recommend you don't use unsafe-total if you can avoid it.

Next let's take a look at the error:

  inferred effect: <state<$a,$h>|_e>
  expected effect: (state<(),_h1>)

I'll take you through my thought process when I was debugging this error, hopefully it is instructional. I don't claim that it is the only way to debug the issue.
Unfortunately, the error doesn't tell us a whole lot. But what it does tell us is interesting:
It seems like a is being inferred as () somewhere. Let's consider where the first type variable of state is being used. It is the return value of get, and a parameter to set. So let's figure out what could be the problem with the operation definitions.

First let's take a look at the handler and what the operation handlers are declared as: both are declared as ctl. This means that we can get a resume function which is great, but it also means that we have to pay special attention to the return value of the operations and the body. Operations with control must have the same result type as the body of the handler (unless you are using return(x) operations to change the return value of normal returns). So let's look at that. Well, action() has a return value of (). Aha, maybe there is something there that is causing the mismatch then. Let's reason about the operations now. foreach usually returns () as well. That is great, since it means it matches what it should return. Okay, let's take a look at !s.inner, oh, that has a value of type a. So one operation wants to be state<(),h> and the other wants to be state<a,h>. That's not going to work. I'm assuming since the operation is called get() that you want to get the value, which means that we need to finally resume. Changing the last line of the operation to resume(!s.inner) works.

2 replies

FayCarsons Jan 16, 2025
Author

Oh man, I didn't even notice that unit inside the state effect! Thank you so much, this is super helpful!

As far as using effects inside of handlers, can we just pass that up to the enclosing function like you've done here? That was what I was attempting to solve with 'unsafe-total'

TimWhiting Jan 16, 2025
Collaborator

Note that I also had to adjust the effects of the signal callbacks.
If you want a more general version which lets code inside with-context access effects defined outside it, you can make things effect polymorphic:

import std/core/unsafe

alias set = list

pub value struct signal<a,h>
  deps:  forall<e> ref<h, set<(a) -> <div,st<h>|e> ()>>
  inner: ref<h, a>

effect state<a,h>
  ctl get( self: signal<a,h>): a
  ctl set( self: signal<a,h>, value: a): ()

pub fun with-context(action: () -> <state<a,h>,div,st<h>|e> ()): <div,st<h>|e> ()
  with handler
    ctl get(s)
      s.deps.modify fn(d)
        Cons(resume, d)
      resume(!s.inner)
    ctl set(s, value)
      s.inner.set(value)
      (!s.deps).foreach fn(dep)
        dep(!s.inner)
  action()

pub fun signal/create(inner: a): <alloc<h>|e> signal<a,h>
  Signal(ref([]), ref(inner))
  
type html
  Div(attrs: list<(string, string)>, children: list<html>)
  P(attrs: list<(string, string)>, info: string)

fun html/show(html: html): div string
  match html
    Div(attrs, children) -> 
      "<div " ++ attrs.map(fn((k, v)) k ++ "=\"" ++ v ++ "\"").join(" ") ++ ">" ++ children.map(show).join("") ++ "</div>"
    P(attrs, info) -> 
      "<p " ++ attrs.map(fn((k, v)) k ++ "=\"" ++ v ++ "\"").join(" ") ++ ">" ++ info ++ "</p>"

fun example()
  with with-context
  val a-signal = signal/create("foo")
  Div(
    [("style", "color: red;")], 
    [P([], a-signal.get())]
  ).show.println
  ()

If you want to force any effects under the scope of with-context to be handled beneath that context you can just keep the effects as I had before. I recommend looking into the named handlers samples as well, I've done some similar things using named handlers in the past: https://github.com/koka-lang/koka/tree/dev/samples/handlers/named.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Performing effects inside handlers? Unclear type error #660

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 1 comment 2 replies

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Select a reply

Performing effects inside handlers? Unclear type error #660

FayCarsons Jan 15, 2025

Replies: 1 comment · 2 replies

TimWhiting Jan 16, 2025 Collaborator

FayCarsons Jan 16, 2025 Author

TimWhiting Jan 16, 2025 Collaborator

FayCarsons
Jan 15, 2025

Replies: 1 comment 2 replies

TimWhiting
Jan 16, 2025
Collaborator

FayCarsons Jan 16, 2025
Author

TimWhiting Jan 16, 2025
Collaborator