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

[Imants Cekusins]

> Why..

what would
    check::A Maybe -> A Identity

do if some A field were Nothing?  fill in a default value?

On 6 July 2017 at 14:13, Baa <aquagnu at gmail.com> wrote:

> Imants, I'm not sure that I understood signatures.
>
> Why
>   check::A Maybe -> Maybe (A Identity)
>
> but not
>   check::A Maybe -> A Identity
>
> ?
>
> To filter (Nothing items must be throw out)? No more reasons for it?
>
>
> > how about a function (or a Monad Transformer) that checks values in
> > one place:
> >
> > check::A Maybe -> Maybe (A Identity)
> >
> > after values were checked, the after-checked functions will deal with
> > A Identity
> >
> > the end result would be
> >    Maybe out
> >
> >
> >
> > On 6 July 2017 at 13:01, Baa <aquagnu at gmail.com> wrote:
> >
> > > But will it work if I switch from one monad to another? Actually, I
> > > have something like piping/conduit, and if I switch items in pipe
> > > from `A Maybe` to `A Idenitity` - will it work? Whether it will be
> > > compiled?
> > >
> > > Although I certainly can "map" items from one type to another...
> > > Idea looks interesting sure :)
> > >
> > >
> > > > Identity
> > > >
> > > > http://hackage.haskell.org/package/mtl-2.2.1/docs/
> > > Control-Monad-Identity.html
> > > >
> > > > may work:
> > > >
> > > >  data A m = A {
> > > >     a1 :: m B
> > > >  }
> > > >   data B m = B {
> > > >     b1 :: m C
> > > >     ... }
> > > >
> > > > m: Maybe or Identity
> > > >
> > > > - any good?
> > > >
> > > >
> > > >
> > > > On 6 July 2017 at 11:12, Baa <aquagnu at gmail.com> wrote:
> > > >
> > > > > Hello Dear List!
> > > > >
> > > > > 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.
> > > > >
> > > > > After processing and filtering, I create, for example, some
> > > > > resulting objects:
> > > > >
> > > > >   data Result {
> > > > >     a :: A -- not Maybe!
> > > > >     ... }
> > > > >
> > > > > And even more: `a::A` in `Result` (I know it, after filtering)
> > > > > will not contain Nothings, only `Just right_values`s.
> > > > >
> > > > > But each function which consumes `A` must do something with
> > > > > possible Nothing values even after filtering and fixing of `A`s.
> > > > >
> > > > > I have, for example, function:
> > > > >
> > > > >   createResults :: [A] -> [Result]
> > > > >   createResults alst =
> > > > >     ...
> > > > >     case of (a1 theA) ->
> > > > >       Just right_value -> ...
> > > > >       Nothing ->
> > > > >         logError
> > > > >         undefined -- can not happen
> > > > >
> > > > > Fun here is: that it happens (I found bug in my filtering
> > > > > code with this `undefined`). But now I thought about it: what
> > > > > is the idiomatic way to solve such situation? When you need to
> > > > > have:
> > > > >
> > > > >   - COMPLEX type WITH Maybes
> > > > >   - the same type WITHOUT Maybes
> > > > >
> > > > > Alternative is to keep this Maybes to the very end of
> > > > > processing, what I don't like. Or to have types copies, which
> > > > > is more terrible, sure.
> > > > >
> > > > > PS. I threw IOs away to show only the crux of the problem.
> > > > >
> > > > > ---
> > > > > Cheers,
> > > > >   Paul
> > > > > _______________________________________________
> > > > > Beginners mailing list
> > > > > Beginners at haskell.org
> > > > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> > > > >
> > >
> > > _______________________________________________
> > > Beginners mailing list
> > > Beginners at haskell.org
> > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> > >
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20170706/9eab8958/attachment.html>