Comment by neonsunset

4 days ago

It is best to just use task CE full-time unless you need specific behavior of async CEs.

The author of the original comment, however, does not know this nor tried verifying whether F# actually works seamlessly with this nowadays (it does).

Writing asynchronous code in F# involves less syntax noise than in C#. None of that boilerplate is required, F# should not be written that way at all.

13 comments

neonsunset

Reply
cjbgkagh  4 days ago

F# is a big language so I think it is to be expected that beginners will not know these things. I don't think the fix is to simplify F# we should just understand that F# is not for everyone and that is ok.

  • neonsunset  4 days ago

    This is perfectly fine, but I think it's better to be unsure about specific language feature than confidently state something that is not correct (anymore).

    Personally, I'm just annoyed by never-ending cycle of ".NET is bad because {reason x}", "When was this the case?", "10 years ago", "So?".

    Like in the example above, chances are you just won't see new F# code do this.

    It will just use task { ... } normally.

shortrounddev2  3 days ago

I understand that you CAN do this, I'm saying that it makes your code look like shit and takes away some of the elegance of ML

  • neonsunset  3 days ago

    Please stop insisting on this. Task CE exists since F# 6.0 and handles awaiting the CoreLib Tasks and ValueTasks without any ceremony.

  • cjbgkagh  3 days ago

    Are you saying you prefer Ocaml to F# or C# to F#? Your example was indeed inelegant but it is also poorly designed as you take 4 lines to reproduce a function that is already built in, people can poorly design code in any language.

    • shortrounddev2  3 days ago

      I'm saying that I wish computation blocks looked better in F#. Instead of:

          let foo id = async {
      let! bar = getBar id
      return bar
    }

      I would prefer

          let async foo id =
      let! bar = getBar id
      bar

      or even something like

          let async foo id =
        getBar! id

      So that computation blocks don't feel like you're switching to an entirely different language. Just wrap the ugliness in the same syntactic sugar that C# does. As it is, C# can achieve arrow syntax with async methods more elegantly than F# can:

          async Task<string> foo(int id) => await getBar(id);

      This, to me, is also part of a larger problem of F# introducing unique keywords for specific language functions instead of reusing keywords, like

          member this.Foo = ...

      and

          member val Foo = ...

      6 replies →