Re: [Haskell-cafe] handling NULL value in database query with Maybe (or other ...)

19 Dec 2018

      thank tou for your C/HASKELL "rosetta stone" about the Monad it helps a
lot understanding the thing...

i always thougt Monads are powerful but they are not easy sot
manipulates syntactically for a beginner in Haskell.

yes in fact what i secretly expected  was a way to discard NULL fields
automagically and it seems really possible with Haskell.

Le 19/12/2018 11:27, Mario Lang a écrit :
...
Damien Mattei  writes:
...
using Nothing and Just compared to other language, it's the same than
if i had written in C something like :
if (x == NULL) printf("NULL\n");
else printf("%s",*x);
i expected more from Haskell...
Haskell actually offers more.
1. The type of "Maybe a" prevents you from ignoring the fact that "a" might
be null.  In C, you can accidentally write
printf("%s",*x);
and risking a segfault.  The compiler will not care.  IN Haskell, the
types dont even allow you to write something like that.  You would be
forced to check for Just or Nothing in one of several ways.
Now, "Maybe a" doesn't only limit your abilities, it also offers you the
functions from the Functor, Applicative and Monad typeclasses.
2. Functor allows you to apply a function to the "a", as long as there is
some "a" inside the "Maybe a".  So, "fmap f x" is roughly equivalent to:
typeOfA f(typeOfA);
typeOfA *x func(typeOfA *x) {
  if (x) {
    typeOfA *val = malloc(sizeof(typeOfA));
    *val = f(*x);
    return val;
  }
  return NULL;
}
func(x);
(note that pure Haskell doesn't have assignment, so the translation to C
is a little bit more verbose then it might be if you were using values
on the stack.)
i tried this:

 let resFMAP = fmap (\(Only a) -> (putStrLn ("a =" ++ Text.unpack a)))
bd_rows_WDS

but compile complains now that i use a Maybe variable instead of a plain
one,strange because this exactly what i expected from Maybe use it to
automatically discard the Nothing values (avoiding to putStrln them):
Prelude> :load UpdateSidonie
[1 of 1] Compiling Main             ( UpdateSidonie.hs, interpreted )

UpdateSidonie.hs:293:75: error:
    • Couldn't match type ‘Maybe Text’ with ‘Text’
      Expected type: [Only Text]
        Actual type: [Only (Maybe Text)]
    • In the second argument of ‘fmap’, namely ‘bd_rows_WDS’
      In the expression:
        fmap (\ (Only a) -> (putStrLn ("a =" ++ unpack a))) bd_rows_WDS
      In an equation for ‘resFMAP’:
          resFMAP
            = fmap (\ (Only a) -> (putStrLn ("a =" ++ unpack a)))
bd_rows_WDS
    |
293 |     let resFMAP = fmap (\(Only a) -> (putStrLn ("a =" ++
Text.unpack a))) bd_rows_WDS
    |
     ^^^^^^^^^^^
Failed, no modules loaded.

bd_rows_WDS is defined like this with a Maybe:

(bd_rows_WDS :: [Only (Maybe Text)]) <- query conn qry_head_WDS (Only
(name::String))

anyway i know enought in haskell now to remove myself the Nothing (NULL)
values of the list doing that (it worked):

-- remove the records having N°BD NULL
    let fltWDS = Prelude.filter (\(Only a) ->
                                    case a of
                                      Nothing -> False
                                      Just a -> True)
                 bd_rows_WDS
...
So you do not need to write an explicit if in Haskell.  The Functor
instance of Maybe "knows" how to deal will null cases.
In particular, if it encounters a Nothing, it returns a Nothing,
ignoring the provided function.
3. Applicative allows you to apply a function to the "a"s of several "Maybe a"
values, returning a Maybe wrapping the result of that function.
So "f <$> x <*> y" is equivalent to
typeOfA f(TypeOfA);
typeOfA *func(typeOfA *x, typeOfA *y) {
  if (x && y) {
    typeOfA *val = malloc(sizeof(typeOfA));
    *val = f(*x, *y);
    return val;
  }
  return NULL;
}
func(x, y);
The amount of boilerplate eliminated grows.
3. Monad allows you to chain several null-checks without having to write
out the nesting.  This time, f, g and h return a "Maybe a", not just an "a":
do
  a <- f x
  b <- g a
  h b
or
f x >>= \a -> g a >>= \b -> h b
is equvalent to something like
typeOfA *f(typeOfA);
typeOfA *g(typeOfA);
typeOfA *h(typeOfA);
typeOfA *func(typeOfA x) {
  if (x) {
    type *a = f(*x);
    if (a) {
      type *b = g(*a);
      if (b) {
        return f(*b);
      }
    }
  }
  return NULL;
}
or, in Haskell:
case f x of
  Just a -> case g a of
    Just b -> h b
    Nothing -> Nothing
  Nothing -> Nothing
The Monad typeclass really pays off, as it saves you from doing the null
checks and dereferencing.  The nested "if null then null" stuff goes all
away, and you can chain several functions together that return a
possible null value.
...
ok reading twice the article in link, i admit there should be some
adavantage using Nothing instead of null, such as type, and genericity
and not being spcecific to alloated memory as in C ...
Exactly.  As I see it, the Functor, Applicative and Monad typeclasses
of the Maybe type give you the tools
necessary to reduce the boilerplate that results from forcing you to
deal with each and every null case in your code.
-- 
Damien.Mattei@unice.fr, Damien.Mattei@oca.eu, UNS / OCA / CNRS