• arc@lemm.ee
    164·
    1 year ago

    Swift and Rust have a far more elegant solution. Swift has a pseudo throw / try-catch, while Rust has a Result<> and if you want to throw it up the chain you can use a ? notation instead of cluttering the code with error checking.

    • barsoap@lemm.ee
      7·
      1 year ago

      The exception handling question mark, spelled ? and abbreviated and pronounced eh?, is a half-arsed copy of monadic error handling. Rust devs really wanted the syntax without introducing HKTs, and admittedly you can’t do foo()?.bar()?.baz()? in Haskell so it’s only theoretical purity which is half-arsed, not ergonomics.

      • Nevoic@lemmy.worldEnglish
        1·
        1 year ago

        Note: Lemmy code blocks don’t play nice with some symbols, specifically < and & in the following code examples

        This isn’t a language level issue really though, Haskell can be equally ergonomic.

        The weird thing about ?. is that it’s actually overloaded, it can mean:

        • call a function on A? that returns B?
        • call a function on A? that returns B

        you’d end up with B? in either case

        Say you have these functions

        toInt :: String -> Maybe Int

double :: Int -> Int

isValid :: Int -> Maybe Int

        and you want to construct the following using these 3 functions

        fn :: Maybe String -> Maybe Int

        in a Rust-type syntax, you’d call

        str?.toInt()?.double()?.isValid()

        in Haskell you’d have two different operators here

        str >>= toInt &lt;&amp;> double >>= isValid

        however you can define this type class

        class Chainable f a b fb where
    (?.) :: f a -> (a -> fb) -> f b

instance Functor f => Chainable f a b b where
    (?.) = (&lt;&amp;>)

instance Monad m => Chainable m a b (m b) where
    (?.) = (>>=)

        and then get roughly the same syntax as rust without introducing a new language feature

        str ?. toInt ?. double ?. isValid

        though this is more general than just Maybes (it works with any functor/monad), and maybe you wouldn’t want it to be. In that case you’d do this

        class Chainable a b fb where
    (?.) :: Maybe a -> (a -> fb) -> Maybe b

instance Chainable a b b where
    (?.) = (&lt;&amp;>)

instance Chainable a b (Maybe b) where
    (?.) = (>>=)

        restricting it to only maybes could also theoretically help type inference.

        • barsoap@lemm.ee
          1·
          1 year ago

          I was thinking along the lines of “you can’t easily get at the wrapped type”. To get at b instead of Maybe b you need to either use do-notation or lambdas (which do-notation is supposed to eliminate because they’re awkward in a monadic context) whereas Rust will gladly hand you that b in the middle of an expression, and doesn’t force you to name the point.

          Or to give a concrete example, if foo()? {...} is rather awkward in Haskell, you end up writing things like

          foo x y = bar >>= baz x y
  where
    baz x y True = x
    baz x y False = y

          , though of course baz is completely generic and can be factored out. I think I called it “cap” in my Haskell days, for “consequent-alternative-predicate”.

          Flattening Functors and Monads syntax-wise is neat but it’s not getting you all the way. But it’s the Haskell way: Instead of macros, use tons upon tons of trivial functions :)

      • arc@lemm.ee
        11·
        1 year ago

        You can say it’s half-arsed if you like, but it’s still vastly more convenient to write than if err != nil all over the place