[Haskell-beginners] Get rid of Maybes in complex types

[Frerich Raabe]

On 2017-07-06 10:12, Baa wrote:
> Consider, I retrieve from external source some data. Internally it's
> represented as some complex type with `Maybe` fields, even more, some
> of fields are record types and have `Maybe` fields too. They are
> Maybe's because some information in this data can be missing (user
> error or it not very valuable and can be skipped):
> 
>   data A = A {
>     a1 :: Maybe B
>     ... }
>   data B = B {
>     b1 :: Maybe C
>     ... }
> 
> I retrieve it from network, files, i.e. external world, then I validate
> it, report errors of some missing fields, fix another one (which can be
> fixed, for example, replace Nothing with `Just default_value` or even I
> can fix `Just wrong` to `Just right`, etc, etc). After all of this, I
> know that I have "clean" data, so all my complex types now have `Just
> right_value` fields. But I need to process them as optional, with
> possible Nothing case! To avoid it I must create copies of `A`, `B`,
> etc, where `a1`, `b1` will be `B`, `C`, not `Maybe B`, `Maybe C`. Sure,
> it's not a case.

I understand that your data structures as sketched above are only needed for 
a short time, when reading/validating/fixing the input data - the rest of the 
program would either report an error (for unrecoverable problems) or process 
the validated data?

In that case, maybe you can avoid using Maybe in your data types for things 
which definitely must be present completely but rather returning a 'Maybe' 
value from your function which retrieves the data, i.e.:

   retrieveData :: ByteString -> Maybe A

Within 'retrieveData' you could then use different weakly-typed data 
structures which maybe only represent subsets of the data as you 
parse/validate/fix it. Not sure if/how that would work out, but maybe you 
could share some more concrete code (e.g. the actual logic for retrieving the 
data and the data types)?

-- 
Frerich Raabe - raabe at froglogic.com
www.froglogic.com - Multi-Platform GUI Testing