Send Beginners mailing list submissions to
beginners@haskell.org
To subscribe or unsubscribe via the World Wide Web, visit
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
beginners-requ...@haskell.org
You can reach the person managing the list at
beginners-ow...@haskell.org
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: Get rid of Maybes in complex types (Imants Cekusins)
2. Re: Get rid of Maybes in complex types (Baa)
----------------------------------------------------------------------
Message: 1
Date: Thu, 6 Jul 2017 14:37:52 +0300
From: Imants Cekusins <ima...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Get rid of Maybes in complex types
Message-ID:
<CAP1qinbAX852SOWWtr5DtcEuj0P=qrzl0wggzkeoahnmc31...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
is it possible to replace Nothing with defaults when A, B are init'ed ?
On 6 July 2017 at 14:33, Baa <aqua...@gmail.com> wrote:
> Hmm, yes. `Nothing` becomes `Identity default_value`. Respectively `A
> Maybe` becomes `A Identity`. I'm not sure will it work but it looks
> alluringly ;)
>
> > > 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 <aqua...@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 <aqua...@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 <aqua...@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@haskell.org
> > > > > > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> > > > > > >
> > > > >
> > > > > _______________________________________________
> > > > > Beginners mailing list
> > > > > Beginners@haskell.org
> > > > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> > > > >
> > >
> > > _______________________________________________
> > > Beginners mailing list
> > > Beginners@haskell.org
> > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> > >
>
> _______________________________________________
> Beginners mailing list
> Beginners@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/0d311450/attachment-0001.html>
------------------------------
Message: 2
Date: Thu, 6 Jul 2017 14:54:02 +0300
From: Baa <aqua...@gmail.com>
To: beginners@haskell.org
Subject: Re: [Haskell-beginners] Get rid of Maybes in complex types
Message-ID: <20170706145402.33f7ca54@Pavel>
Content-Type: text/plain; charset=US-ASCII
Unfortunately, no.
> is it possible to replace Nothing with defaults when A, B are
> init'ed ?
>
> On 6 July 2017 at 14:33, Baa <aqua...@gmail.com> wrote:
>
> > Hmm, yes. `Nothing` becomes `Identity default_value`. Respectively
> > `A Maybe` becomes `A Identity`. I'm not sure will it work but it
> > looks alluringly ;)
> >
> > > > 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 <aqua...@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 <aqua...@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 <aqua...@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@haskell.org
> > > > > > > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> > > > > > > >
> > > > > >
> > > > > > _______________________________________________
> > > > > > Beginners mailing list
> > > > > > Beginners@haskell.org
> > > > > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> > > > > >
> > > >
> > > > _______________________________________________
> > > > Beginners mailing list
> > > > Beginners@haskell.org
> > > > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> > > >
> >
> > _______________________________________________
> > Beginners mailing list
> > Beginners@haskell.org
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> >
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 109, Issue 8
*****************************************
