Simple Functional Effects with Tag Unions • Richard Feldman • YOW! 2022

Sdílet
Vložit
  • čas přidán 27. 08. 2024

Komentáře • 20

  • @paryoticu
    @paryoticu Před 11 měsíci +8

    Roc is getting an effect system, which will be async-capable and will use continuation-passing-style.
    Wow, terrific news if I understood correctly. Great presentation as always rtfeldman.

  • @angeloceccato
    @angeloceccato Před rokem +5

    I like the effect system + the row polimorphism of Roc 😍

  • @csbnikhil
    @csbnikhil Před rokem +15

    For Rust though, map_err calls can be avoided. But that will come at the cost of writing std::convert::From implementations for each.

  • @ShawnShaddock
    @ShawnShaddock Před rokem +4

    Great video, Roc sounds really cool!

  • @humanlytyped
    @humanlytyped Před rokem +4

    This is exactly final encoding vs initial encoding.
    With algebraic data types, we can pair initial encoding with the interpreter pattern to obtain extensible effects.
    OOP simulates sum types using ad-hoc polymorphism, so we can pair final encoding and the decorator pattern to obtain extensible effects.
    I like how Roc automatically extends the tags returned from a function. There is probably an analogue in OCaml, I think it's row polymorphism.

    • @csbnikhil
      @csbnikhil Před rokem

      In OCaml, Polymorphic Variants enable Row Polymorphism.

  • @humanlytyped
    @humanlytyped Před rokem +6

    35:07 isn't this part a monadic bind?

    • @pdp11
      @pdp11 Před 6 měsíci

      That's just an artefact of the fact that effects can be encoded by monads.

  • @aloussase
    @aloussase Před rokem +2

    Do syntax would avoid all those Task.await. Event F# has something like that with computation expressions.

  • @renghenkow
    @renghenkow Před rokem +2

    very similar to what nim has as an effect system

  • @JT-mr3db
    @JT-mr3db Před rokem +1

    This looks very similar to how Parser combinators work. Parsers returning parsers.

  • @MaksimVolkau
    @MaksimVolkau Před rokem +1

    Scala3 ZIO in Roc but without the environment, right?

  • @minecraftermad
    @minecraftermad Před 4 měsíci +1

    missed chance to mention zig :)

  • @markhamburg5535
    @markhamburg5535 Před 10 měsíci

    How easy does Roc make it to specify that a piece of code is only allowed to perform some effects but not others? For example, could one specify that when running a database transaction we would allow access to the local file system but not to the network in order to limit task latency while holding a connection open on the database? Presumably this would show up as an explicit type for the third type argument for Task? Would the Roc compiler then present an error at the point where you tried to perform a disallowed task or would it error out at the point where the type was explicitly specified?

  • @walrustrent2001
    @walrustrent2001 Před 11 měsíci +1

    The non-capabilities seem like capabilities to me.
    Effects are specific beasts that need to be distinguished from purely functional code as much as possible.

  • @Mik1604
    @Mik1604 Před rokem

    How is map_err specifically used for Errors only? It seems to me like something like map_type is much more generic and useful.

    • @Qrzychu92
      @Qrzychu92 Před rokem

      it's basically monadic bind (your map_type), but for the error path of the code instead of success

  • @MarkusBurrer
    @MarkusBurrer Před 6 měsíci

    Is IT possible to do the same Thing in Rust?

    • @user-uf4rx5ih3v
      @user-uf4rx5ih3v Před 5 měsíci

      Yes it is. But I imagine it wont be as ergonomic as this because you would have to implement the Task monad manually everywhere. Most of the functional features of Rust are first class because otherwise using them is not nice. Perhaps if you could derive Task automatically with macros but I'm not a big Rust expert so I don't know.