Trying to decode Object to enum successfully compile but fails to pattern match

[qonn]

The example below should have rendered "abcdef 1234567", but it does not.

enum Foo {
  Bar(String, Number)
  Foo
}

module Foo {
  fun decoder (object: Object) : Result(Object.Error, Foo) {
    with Object.Decode {
      try {
        decodedFoo =
          object
            |> field("foo", string)

        decodedBar =
          object
            |> field("bar", number)

        Debug.log(Foo::Bar(decodedFoo, decodedBar))

        Result::Ok(Foo::Bar(decodedFoo, decodedBar))
      } catch Object.Error => error {
        Result::Err(error)
      }
    }
  }

  fun decode () : Foo {
    try {
      test =
        encode { foo = "abcdef", bar = 1234567 }

      maybeFoo =
        Object.Decode.maybe(decoder, test)

      Debug.log(maybeFoo)

      case (maybeFoo) {
        Maybe::Just foobar => foobar
        Maybe::Nothing => Foo::Foo
      }

    } catch Object.Error => error {
      Foo::Foo
    }
  }

  fun render : Html {
    case (foo) {
      Foo::Bar foo bar =>
        <div>
          "#{foo} #{bar}"
        </div>

      Foo::Foo =>
        <div>
          "Hmm"
        </div>
    }
  } where {
    foo = decode()
  }
}

component Main {
  fun render : Html {
    <div>
      <{ Foo.render()  }>
    </div>
  }
}

[gdotdesign]

The issue was that type checking phase was not in line with the compiling phase: the result at the end of the try was unboxed where it should not have been.

It's fixed on master and in the docker repository as well.