mempty and "No instance for (Monoid Int)"

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
5 messages Options
Baa
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

mempty and "No instance for (Monoid Int)"

Baa
Maybe a is the Monoid:

  instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’

so I can compare its values with empty value:

  mempty == Nothing
  => True

But if I try:

  mempty == Just 4

I get:

  <interactive>:1:1: error:
      • Ambiguous type variable ‘a0’ arising from a use of ‘mempty’
        prevents the constraint ‘(Monoid a0)’ from being solved.
        Probable fix: use a type annotation to specify what ‘a0’ should
         be. These potential instances exist:
          instance Monoid a => Monoid (IO a) -- Defined in ‘GHC.Base’
          instance Monoid Ordering -- Defined in ‘GHC.Base’
          instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
          ...plus 7 others
          (use -fprint-potential-instances to see them all)
      • In the first argument of ‘(==)’, namely ‘mempty’
        In the expression: mempty == Just 4
        In an equation for ‘it’: it = mempty == Just 4

OK, I try:

  mempty::Maybe Int

and get:

  <interactive>:1:1: error:
      • No instance for (Monoid Int) arising from a use of ‘mempty’
      • In the expression: mempty :: Maybe Int
        In an equation for ‘it’: it = mempty :: Maybe Int

so, how is related Int to Monoid, why does ghc expect from mempty::Maybe
Int, Int to be Monoid?! As I understand, this means only that I
mean "mempty" from (Maybe Int) type, which is Monoid and exists sure.

Interesting is, that:

  mempty::Maybe [Int]
  => Nothing

but how is related "monoidality" of "Maybe a" with "monoidality of
"a" ???

Initial idea was to make comparison:

  mempty :: Maybe Int == Just 4
  => False


/Best regards,
  Paul
_______________________________________________
Beginners mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: mempty and "No instance for (Monoid Int)"

David McBride
In ghci there are type defaulting rules.  When you go mempty ==
Nothing, it type defaults it to "Maybe ()".  But when you type Just 4,
4 is definitely not (), and so it looks at the Monoid instance for the
a default type to use in cases of numeric literals, the first of which
is Int.

Which brings you to the next problem.  Maybe Int is only a Monoid if
Int is an instance of Monoid, and Int is definitely not.

That's because is 3 `mappend` 3 == 6 via addition?  Or should it be 9
via multiplication?  Or something else?  What should mempty be, 0?  Or
maybe 1?  Who is to decide what the only way of combining Ints
together is.

It turns out there are instances for both of those cases, but you have
to wrap the int into a type so that it knows which way you want it to
be interpreted.

import Data.Monoid
mempty == Just (Product 1)
> false
mempty == Just (Sum 1)
> false

There are similar monoidal instances for Bool, such as Any and All.

On Wed, Jun 7, 2017 at 12:33 PM, Baa <[hidden email]> wrote:

> Maybe a is the Monoid:
>
>   instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
>
> so I can compare its values with empty value:
>
>   mempty == Nothing
>   => True
>
> But if I try:
>
>   mempty == Just 4
>
> I get:
>
>   <interactive>:1:1: error:
>       • Ambiguous type variable ‘a0’ arising from a use of ‘mempty’
>         prevents the constraint ‘(Monoid a0)’ from being solved.
>         Probable fix: use a type annotation to specify what ‘a0’ should
>          be. These potential instances exist:
>           instance Monoid a => Monoid (IO a) -- Defined in ‘GHC.Base’
>           instance Monoid Ordering -- Defined in ‘GHC.Base’
>           instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
>           ...plus 7 others
>           (use -fprint-potential-instances to see them all)
>       • In the first argument of ‘(==)’, namely ‘mempty’
>         In the expression: mempty == Just 4
>         In an equation for ‘it’: it = mempty == Just 4
>
> OK, I try:
>
>   mempty::Maybe Int
>
> and get:
>
>   <interactive>:1:1: error:
>       • No instance for (Monoid Int) arising from a use of ‘mempty’
>       • In the expression: mempty :: Maybe Int
>         In an equation for ‘it’: it = mempty :: Maybe Int
>
> so, how is related Int to Monoid, why does ghc expect from mempty::Maybe
> Int, Int to be Monoid?! As I understand, this means only that I
> mean "mempty" from (Maybe Int) type, which is Monoid and exists sure.
>
> Interesting is, that:
>
>   mempty::Maybe [Int]
>   => Nothing
>
> but how is related "monoidality" of "Maybe a" with "monoidality of
> "a" ???
>
> Initial idea was to make comparison:
>
>   mempty :: Maybe Int == Just 4
>   => False
>
>
> /Best regards,
>   Paul
> _______________________________________________
> Beginners mailing list
> [hidden email]
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________
Beginners mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
Baa
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: mempty and "No instance for (Monoid Int)"

Baa
> In ghci there are type defaulting rules.  When you go mempty ==
> Nothing, it type defaults it to "Maybe ()".

Aha, OK. These defaults are preset also in non-interactive: I tried the
same and get the same result.

> But when you type Just 4,
> 4 is definitely not (), and so it looks at the Monoid instance for the
> a default type to use in cases of numeric literals, the first of which
> is Int.

This I can not understand. Literal "4" is under "Just", so why are we
talking about "Int" as Monoid but not about "Maybe Int" as Monoid? And
"Maybe Int" as Monoid does not depend on Int and is the same for "Maybe
Int", "Maybe Bool", "Maybe String"... When I added type annotation, like
"::Maybe Int", I suppose, usual "Maybe a"'s implementations of
"mempty", "mappend" will be used, - no more defaults. Seems it is not
true, but why?


>
> Which brings you to the next problem.  Maybe Int is only a Monoid if
> Int is an instance of Monoid, and Int is definitely not.
>

I don't understand it. Monoid is "Maybe a" for any "a". And I can
understand your point if we are talking only for interactive GHCI and
its defaults, but when I tried in source code to write:

  m :: Maybe Int
  m = mempty
  ...
  ... print $ Nothing == m

i get the same, about no instance for (Monoid Int). But Maybe's "mempty"
is "Nothing", nothing else. And its "mappend" processes any (Just _) and
Nothing's, right? May be all magic is from defaults?


> That's because is 3 `mappend` 3 == 6 via addition?  Or should it be 9
> via multiplication?  Or something else?  What should mempty be, 0?  Or
> maybe 1?  Who is to decide what the only way of combining Ints
> together is.
>
> It turns out there are instances for both of those cases, but you have
> to wrap the int into a type so that it knows which way you want it to
> be interpreted.
>
> import Data.Monoid
> mempty == Just (Product 1)
> > false  
> mempty == Just (Sum 1)
> > false  

Yes, this is absolutely understandable. Except one detail:

  Prelude Data.Monoid Data.Maybe> mempty == Product 1
  True
  Prelude Data.Monoid Data.Maybe> mempty == Just (Product 1)
  False

so, "Product Int" as Monoid and "Maybe (Product Int)" as Monoid are totally
different, - I understand what is Abel's groups on + and *, but I don't
understand why GHC looks for Monoid instance for Int while Int is under
Maybe... It will be right if:

  instance (Monoid a) => Monoid (Maybe a) where
    ...

but is it true?! I suppose no such constraint on "a". Is it all due to
defaults? Or I lost my brain at this night :)


/Best regards, Paul


>
> There are similar monoidal instances for Bool, such as Any and All.
>
> On Wed, Jun 7, 2017 at 12:33 PM, Baa <[hidden email]> wrote:
> > Maybe a is the Monoid:
> >
> >   instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
> >
> > so I can compare its values with empty value:
> >
> >   mempty == Nothing  
> >   => True  
> >
> > But if I try:
> >
> >   mempty == Just 4
> >
> > I get:
> >
> >   <interactive>:1:1: error:
> >       • Ambiguous type variable ‘a0’ arising from a use of ‘mempty’
> >         prevents the constraint ‘(Monoid a0)’ from being solved.
> >         Probable fix: use a type annotation to specify what ‘a0’
> > should be. These potential instances exist:
> >           instance Monoid a => Monoid (IO a) -- Defined in
> > ‘GHC.Base’ instance Monoid Ordering -- Defined in ‘GHC.Base’
> >           instance Monoid a => Monoid (Maybe a) -- Defined in
> > ‘GHC.Base’ ...plus 7 others
> >           (use -fprint-potential-instances to see them all)
> >       • In the first argument of ‘(==)’, namely ‘mempty’
> >         In the expression: mempty == Just 4
> >         In an equation for ‘it’: it = mempty == Just 4
> >
> > OK, I try:
> >
> >   mempty::Maybe Int
> >
> > and get:
> >
> >   <interactive>:1:1: error:
> >       • No instance for (Monoid Int) arising from a use of ‘mempty’
> >       • In the expression: mempty :: Maybe Int
> >         In an equation for ‘it’: it = mempty :: Maybe Int
> >
> > so, how is related Int to Monoid, why does ghc expect from
> > mempty::Maybe Int, Int to be Monoid?! As I understand, this means
> > only that I mean "mempty" from (Maybe Int) type, which is Monoid
> > and exists sure.
> >
> > Interesting is, that:
> >
> >   mempty::Maybe [Int]  
> >   => Nothing  
> >
> > but how is related "monoidality" of "Maybe a" with "monoidality of
> > "a" ???
> >
> > Initial idea was to make comparison:
> >
> >   mempty :: Maybe Int == Just 4  
> >   => False  
> >
> >
> > /Best regards,
> >   Paul
> > _______________________________________________
> > Beginners mailing list
> > [hidden email]
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners 
> _______________________________________________
> Beginners mailing list
> [hidden email]
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners



--
Best regards,
  Paul a.k.a. 6apcyk
_______________________________________________
Beginners mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: mempty and "No instance for (Monoid Int)"

David McBride
I glossed over the key fact

> Maybe Int is only a Monoid if Int is an instance of Monoid

This is derived from the Monoid instance of Maybe.

instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’

Maybe is only an instance if a is an instance.  If a isn't then Maybe
isn't either, and it will be rejected.  That is why Maybe Int is not a
Monoid, but Maybe (Product Int) and Maybe () are.


On Wed, Jun 7, 2017 at 2:53 PM, aquagnu <[hidden email]> wrote:

>> In ghci there are type defaulting rules.  When you go mempty ==
>> Nothing, it type defaults it to "Maybe ()".
>
> Aha, OK. These defaults are preset also in non-interactive: I tried the
> same and get the same result.
>
>> But when you type Just 4,
>> 4 is definitely not (), and so it looks at the Monoid instance for the
>> a default type to use in cases of numeric literals, the first of which
>> is Int.
>
> This I can not understand. Literal "4" is under "Just", so why are we
> talking about "Int" as Monoid but not about "Maybe Int" as Monoid? And
> "Maybe Int" as Monoid does not depend on Int and is the same for "Maybe
> Int", "Maybe Bool", "Maybe String"... When I added type annotation, like
> "::Maybe Int", I suppose, usual "Maybe a"'s implementations of
> "mempty", "mappend" will be used, - no more defaults. Seems it is not
> true, but why?
>
>
>>
>> Which brings you to the next problem.  Maybe Int is only a Monoid if
>> Int is an instance of Monoid, and Int is definitely not.
>>
>
> I don't understand it. Monoid is "Maybe a" for any "a". And I can
> understand your point if we are talking only for interactive GHCI and
> its defaults, but when I tried in source code to write:
>
>   m :: Maybe Int
>   m = mempty
>   ...
>   ... print $ Nothing == m
>
> i get the same, about no instance for (Monoid Int). But Maybe's "mempty"
> is "Nothing", nothing else. And its "mappend" processes any (Just _) and
> Nothing's, right? May be all magic is from defaults?
>
>
>> That's because is 3 `mappend` 3 == 6 via addition?  Or should it be 9
>> via multiplication?  Or something else?  What should mempty be, 0?  Or
>> maybe 1?  Who is to decide what the only way of combining Ints
>> together is.
>>
>> It turns out there are instances for both of those cases, but you have
>> to wrap the int into a type so that it knows which way you want it to
>> be interpreted.
>>
>> import Data.Monoid
>> mempty == Just (Product 1)
>> > false
>> mempty == Just (Sum 1)
>> > false
>
> Yes, this is absolutely understandable. Except one detail:
>
>   Prelude Data.Monoid Data.Maybe> mempty == Product 1
>   True
>   Prelude Data.Monoid Data.Maybe> mempty == Just (Product 1)
>   False
>
> so, "Product Int" as Monoid and "Maybe (Product Int)" as Monoid are totally
> different, - I understand what is Abel's groups on + and *, but I don't
> understand why GHC looks for Monoid instance for Int while Int is under
> Maybe... It will be right if:
>
>   instance (Monoid a) => Monoid (Maybe a) where
>     ...
>
> but is it true?! I suppose no such constraint on "a". Is it all due to
> defaults? Or I lost my brain at this night :)
>
>
> /Best regards, Paul
>
>
>>
>> There are similar monoidal instances for Bool, such as Any and All.
>>
>> On Wed, Jun 7, 2017 at 12:33 PM, Baa <[hidden email]> wrote:
>> > Maybe a is the Monoid:
>> >
>> >   instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
>> >
>> > so I can compare its values with empty value:
>> >
>> >   mempty == Nothing
>> >   => True
>> >
>> > But if I try:
>> >
>> >   mempty == Just 4
>> >
>> > I get:
>> >
>> >   <interactive>:1:1: error:
>> >       • Ambiguous type variable ‘a0’ arising from a use of ‘mempty’
>> >         prevents the constraint ‘(Monoid a0)’ from being solved.
>> >         Probable fix: use a type annotation to specify what ‘a0’
>> > should be. These potential instances exist:
>> >           instance Monoid a => Monoid (IO a) -- Defined in
>> > ‘GHC.Base’ instance Monoid Ordering -- Defined in ‘GHC.Base’
>> >           instance Monoid a => Monoid (Maybe a) -- Defined in
>> > ‘GHC.Base’ ...plus 7 others
>> >           (use -fprint-potential-instances to see them all)
>> >       • In the first argument of ‘(==)’, namely ‘mempty’
>> >         In the expression: mempty == Just 4
>> >         In an equation for ‘it’: it = mempty == Just 4
>> >
>> > OK, I try:
>> >
>> >   mempty::Maybe Int
>> >
>> > and get:
>> >
>> >   <interactive>:1:1: error:
>> >       • No instance for (Monoid Int) arising from a use of ‘mempty’
>> >       • In the expression: mempty :: Maybe Int
>> >         In an equation for ‘it’: it = mempty :: Maybe Int
>> >
>> > so, how is related Int to Monoid, why does ghc expect from
>> > mempty::Maybe Int, Int to be Monoid?! As I understand, this means
>> > only that I mean "mempty" from (Maybe Int) type, which is Monoid
>> > and exists sure.
>> >
>> > Interesting is, that:
>> >
>> >   mempty::Maybe [Int]
>> >   => Nothing
>> >
>> > but how is related "monoidality" of "Maybe a" with "monoidality of
>> > "a" ???
>> >
>> > Initial idea was to make comparison:
>> >
>> >   mempty :: Maybe Int == Just 4
>> >   => False
>> >
>> >
>> > /Best regards,
>> >   Paul
>> > _______________________________________________
>> > Beginners mailing list
>> > [hidden email]
>> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>> _______________________________________________
>> Beginners mailing list
>> [hidden email]
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
>
>
> --
> Best regards,
>   Paul a.k.a. 6apcyk
> _______________________________________________
> Beginners mailing list
> [hidden email]
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________
Beginners mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
Baa
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: mempty and "No instance for (Monoid Int)"

Baa
> I glossed over the key fact
>
> > Maybe Int is only a Monoid if Int is an instance of Monoid  
>
> This is derived from the Monoid instance of Maybe.
>
> instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’

Ooohh... I see. Thank you a lot!
No magic again :)

/Best regards,
  Paul


>
> Maybe is only an instance if a is an instance.  If a isn't then Maybe
> isn't either, and it will be rejected.  That is why Maybe Int is not a
> Monoid, but Maybe (Product Int) and Maybe () are.
>
>
> On Wed, Jun 7, 2017 at 2:53 PM, aquagnu <[hidden email]> wrote:
> >> In ghci there are type defaulting rules.  When you go mempty ==
> >> Nothing, it type defaults it to "Maybe ()".  
> >
> > Aha, OK. These defaults are preset also in non-interactive: I tried
> > the same and get the same result.
> >  
> >> But when you type Just 4,
> >> 4 is definitely not (), and so it looks at the Monoid instance for
> >> the a default type to use in cases of numeric literals, the first
> >> of which is Int.  
> >
> > This I can not understand. Literal "4" is under "Just", so why are
> > we talking about "Int" as Monoid but not about "Maybe Int" as
> > Monoid? And "Maybe Int" as Monoid does not depend on Int and is the
> > same for "Maybe Int", "Maybe Bool", "Maybe String"... When I added
> > type annotation, like "::Maybe Int", I suppose, usual "Maybe a"'s
> > implementations of "mempty", "mappend" will be used, - no more
> > defaults. Seems it is not true, but why?
> >
> >  
> >>
> >> Which brings you to the next problem.  Maybe Int is only a Monoid
> >> if Int is an instance of Monoid, and Int is definitely not.
> >>  
> >
> > I don't understand it. Monoid is "Maybe a" for any "a". And I can
> > understand your point if we are talking only for interactive GHCI
> > and its defaults, but when I tried in source code to write:
> >
> >   m :: Maybe Int
> >   m = mempty
> >   ...
> >   ... print $ Nothing == m
> >
> > i get the same, about no instance for (Monoid Int). But Maybe's
> > "mempty" is "Nothing", nothing else. And its "mappend" processes
> > any (Just _) and Nothing's, right? May be all magic is from
> > defaults?
> >
> >  
> >> That's because is 3 `mappend` 3 == 6 via addition?  Or should it
> >> be 9 via multiplication?  Or something else?  What should mempty
> >> be, 0?  Or maybe 1?  Who is to decide what the only way of
> >> combining Ints together is.
> >>
> >> It turns out there are instances for both of those cases, but you
> >> have to wrap the int into a type so that it knows which way you
> >> want it to be interpreted.
> >>
> >> import Data.Monoid
> >> mempty == Just (Product 1)  
> >> > false  
> >> mempty == Just (Sum 1)  
> >> > false  
> >
> > Yes, this is absolutely understandable. Except one detail:
> >
> >   Prelude Data.Monoid Data.Maybe> mempty == Product 1
> >   True
> >   Prelude Data.Monoid Data.Maybe> mempty == Just (Product 1)
> >   False
> >
> > so, "Product Int" as Monoid and "Maybe (Product Int)" as Monoid are
> > totally different, - I understand what is Abel's groups on + and *,
> > but I don't understand why GHC looks for Monoid instance for Int
> > while Int is under Maybe... It will be right if:
> >
> >   instance (Monoid a) => Monoid (Maybe a) where
> >     ...
> >
> > but is it true?! I suppose no such constraint on "a". Is it all due
> > to defaults? Or I lost my brain at this night :)
> >
> >
> > /Best regards, Paul
> >
> >  
> >>
> >> There are similar monoidal instances for Bool, such as Any and All.
> >>
> >> On Wed, Jun 7, 2017 at 12:33 PM, Baa <[hidden email]> wrote:  
> >> > Maybe a is the Monoid:
> >> >
> >> >   instance Monoid a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
> >> >
> >> > so I can compare its values with empty value:
> >> >
> >> >   mempty == Nothing  
> >> >   => True  
> >> >
> >> > But if I try:
> >> >
> >> >   mempty == Just 4
> >> >
> >> > I get:
> >> >
> >> >   <interactive>:1:1: error:
> >> >       • Ambiguous type variable ‘a0’ arising from a use of
> >> > ‘mempty’ prevents the constraint ‘(Monoid a0)’ from being solved.
> >> >         Probable fix: use a type annotation to specify what ‘a0’
> >> > should be. These potential instances exist:
> >> >           instance Monoid a => Monoid (IO a) -- Defined in
> >> > ‘GHC.Base’ instance Monoid Ordering -- Defined in ‘GHC.Base’
> >> >           instance Monoid a => Monoid (Maybe a) -- Defined in
> >> > ‘GHC.Base’ ...plus 7 others
> >> >           (use -fprint-potential-instances to see them all)
> >> >       • In the first argument of ‘(==)’, namely ‘mempty’
> >> >         In the expression: mempty == Just 4
> >> >         In an equation for ‘it’: it = mempty == Just 4
> >> >
> >> > OK, I try:
> >> >
> >> >   mempty::Maybe Int
> >> >
> >> > and get:
> >> >
> >> >   <interactive>:1:1: error:
> >> >       • No instance for (Monoid Int) arising from a use of
> >> > ‘mempty’ • In the expression: mempty :: Maybe Int
> >> >         In an equation for ‘it’: it = mempty :: Maybe Int
> >> >
> >> > so, how is related Int to Monoid, why does ghc expect from
> >> > mempty::Maybe Int, Int to be Monoid?! As I understand, this means
> >> > only that I mean "mempty" from (Maybe Int) type, which is Monoid
> >> > and exists sure.
> >> >
> >> > Interesting is, that:
> >> >
> >> >   mempty::Maybe [Int]  
> >> >   => Nothing  
> >> >
> >> > but how is related "monoidality" of "Maybe a" with "monoidality
> >> > of "a" ???
> >> >
> >> > Initial idea was to make comparison:
> >> >
> >> >   mempty :: Maybe Int == Just 4  
> >> >   => False  
> >> >
> >> >
> >> > /Best regards,
> >> >   Paul
> >> > _______________________________________________
> >> > Beginners mailing list
> >> > [hidden email]
> >> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners 
> >> _______________________________________________
> >> Beginners mailing list
> >> [hidden email]
> >> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners 
> >
> >
> >
> > --
> > Best regards,
> >   Paul a.k.a. 6apcyk
> > _______________________________________________
> > Beginners mailing list
> > [hidden email]
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners 
> _______________________________________________
> Beginners mailing list
> [hidden email]
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners



--
Best regards,
  Paul a.k.a. 6apcyk
_______________________________________________
Beginners mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
Loading...