Stream: beginners

Topic: Inferred error union

Maxime Pigeon (Aug 23 2026 at 14:35):

Hi! Say I've got an HTTP request handler calling a bunch of functions that can fail. Is there a way for the handler to return a Try with a union of all the errors, without having to specify all the error tags in the signature? In other words, can Roc infer the error set like in Zig?

Maxime Pigeon (Aug 23 2026 at 14:37):

I tried handler : Server.Request => Try(Response, _) and handler : Server.Request => Try(Response, [..]) but it doesn't seem to work.

Maxime Pigeon (Aug 23 2026 at 14:39):

I understand I can convert the different errors into, say, a ServerErr, but then I've got a bunch of can_fail() ? |err| ServerErr(Str.inspect(err).

boof (Aug 23 2026 at 16:14):

I've run into the related issue, I suppose. In the example below there is a function parse_uri which is needed to use ?

I suppose the root cause of it is ParseErr which is not open union tag

app [main!] {
    pf: platform "https://github.com/roc-lang/basic-cli/releases/download/0.22.0/F1JVZPYfWP71s8vk6tHcV1Qx1Ef6CZkwswGoCn8VHZmL.tar.zst",
    http: "https://github.com/roc-lang/http/releases/download/2.0.0/6ZUwqYhCS8PU9Mo6MF7oV82ET2o7KYb57CLKDq4cq4sS.tar.zst",
}

import pf.Path
import pf.Stdout
import pf.Stderr
import pf.Url
import pf.OsStr
import pf.Http

import http.Method
import http.Request

main! : List(OsStr) => Try({}, [Exit(I32), ..])
main! = |args| {
    match run!(args) {
        Ok({}) => Ok({})
        Err(err) => {
            _ = Stderr.line!("Runtime error: ${Str.inspect(err)}")

            Err(Exit(2))
        }
    }
}

run! = |_args| {
    uri = "https://"

    _ = parse_uri(uri)?
    request = Request.from_method(GET).with_uri(uri)

    Stdout.line!("${request.method().to_str()} ${request.uri()}")?

    response = Http.send!(request)?

    response.headers().for_each!(
        |header| {
            dbg "${header.name}: ${header.value}"
        },
    )

    dbg response.status().to_str()
    dbg Str.from_utf8(response.body())?

    Ok({})
}

parse_uri : Str -> Try(Url, [InvalidUrl(Url.ParseErr), ..])
parse_uri = |uri| {
    match Url.parse(uri) {
        Ok(url) => Ok(url)
        Err(err) => Err(InvalidUrl(err))
    }
}

Maxime Pigeon (Aug 23 2026 at 20:40):

Here's another example:

read_json! : Server.Request => Try(Str, _)
read_json! = |request|
    request.body().with_limit(16 * 1024).read_all!()?
        |> Str.from_utf8

Ideally, the inferred type would be [BadUtf8, RequestBodyErr] or something like that, but I get a type mismatch. I suppose, like @boof , it's because read_all!'s error union is closed?

Aurélien Geron (Aug 23 2026 at 21:03):

Yes, it's probably because read_all! returns a closed union. You can work around this issue by using (x.read_all!() ? |RequestBodyErr(err)|RequestBodyErr(err)). Not ideal, but hopefully this will become automatic in the future.

Luke Boswell (Aug 23 2026 at 21:30):

Aurélien Geron said:

Yes, it's probably because read_all! returns a closed union. You can work around this issue by using (x.read_all!() ? |RequestBodyErr(err)|RequestBodyErr(err)). Not ideal, but hopefully this will become automatic in the future.

I believe this is what @Jared Ramirez is working on in https://github.com/roc-lang/roc/pull/10434

Last updated: Sep 03 2026 at 15:16 UTC