Re:Fantasy World OCaml (2013)
by rwmj on Sunday August 03, 2014 @06:30AM
(#8127590)
I would like to see a 'return' statement added to the language, so that:
is the equivalent of:
Note that type safety would obviously have to be preserved. The returned type would have to match the return type of the overall function.
[ Parent
| on HN ]
I think this is pretty intentionally avoided most of the time since it clutters up the continuation-passing semantics of the code... With `return` you have a much more complex base language. Especially since you can achieve it using monads.
Monads don't (quite) short-circuit the later computations unlike a return statement. Anyway, I'd like to see an example of writing this using monads, since it makes the idea more concrete.
I can write a continuation monad in Haskell which would. Something like
{-# LANGUAGE DeriveFunctor #-}
module Return where
import Control.Monad
newtype Cont r a = Cont { runCont :: (a -> r) -> r } deriving Functor
instance Monad (Cont r) where
return a = Cont (\k -> k a)
m >>= f = Cont (\k -> runCont m (\a -> runCont (f a) k))
early :: r -> Cont r a
early a = Cont (\_ -> a)
ex :: Cont Integer [Integer]
ex = do
forM [1..] $ \i -> do
when (i == 33) (early i)
return iWhy Cont when Either would do?
True, but I mentioned continuation-passing semantics! Peaker's right though—and Either might be a little easier to understand.
Re:Fantasy World OCaml (2013)
by theaeolist on Sunday August 03, 2014 @08:07AM
(#8127719)
Why?
Because it would make a lot of code less nested and simpler to understand. The most common case is:
if some_error_condition then
None
else (
// everything else in the function is nested
)
which would be replaced with: if some_error_condition then
return None;
// everything else is not nested
The situation is particularly bad when you have to do a lot of small tests at the beginning of your function. Think permissions checks: let user_id =
match user with Some id -> id
| None ->
printf "you need to specify a user\n";
return None in
if not (permitted user_id) then
printf "this user is not permitted\n";
return None;
// go ahead and return Some object
The alternative is to use exceptions, either hidden within the function (requiring a nested function), or demanding that the caller is careful about catching exceptions. Exceptions are an unsafe back door, when what's really needed is a return statement.Original code:
if some_error_condition then
None
else (
// everything else in the function is nested
)
Why not use a Maybe/Either monad like: x <- some_maybe_value
// everything else in the function isn't nested, and "x" is available (if some_maybe_value was Just)
Kind of like exceptions, but a bit more explicit.I don't understand your example. I don't want to run the "// everything else" bit if the error condition was true.
The error condition is represented by Nothing ("None" in OCaml?) and the rest of the code only runs if it was Just ("Some" in OCaml?).
A style I sometimes see is people not indenting the normal code path of the match. So your example above would be written:
match user with
| None -> printf "you need to specify a user\n"; None
| Some user_id when not (permitted user_id) ->
printf "this user is not permitted\n"; None
| Some user_id ->
// go ahead and return Some objectStay classy, downvoters. You know I've been a working OCaml programmer for the last 12 years, using the language most days, so I do know a bit about the pain points.