From austinzhu666 at gmail.com  Fri Aug  7 14:11:43 2020
From: austinzhu666 at gmail.com (Austin Zhu)
Date: Fri, 7 Aug 2020 23:11:43 +0900
Subject: [Haskell-beginners] Understanding functions like f a b c = c $ b a
Message-ID: <CAM2mjt_y2=rT_Gz3VWH+e1xb+A1US+KoaKvHS1TskrPM3BxTPw@mail.gmail.com>

Hello!

I'm learning Haskell and I found an interesting implementation of init
using foldr. However I have difficulty understand how it works.

*init' xs = foldr f (const []) xs id*
*    where f x g h = h $ g (x:)*

Consider I have a input of *[1,2,3]*, then is would become

*f 1 (f 2 ( f 3 (const []))) id*

I substitute those parameters into f and the innermost one becomes *h $
(const []) (1:)*, which is simply *h []*. However when I want to reduce the
expression further, I found it's hard to grasp. The next one becomes *f 2
(h [])* , which is

*h $ (h []) (2:)*

if it works like that. This looks confusing to me. To match the type of
*foldr*, h should be of type *[a] -> [a]* and *h []* would just be of type
*[a]*, which isn't applicable to *(2:)*.

I also thought it in another way that *f x g* returns a function of type *([a]
-> [a]) -> [a],* this kinda makes sense considering applying *id*
afterwards. But then I realized I still don't know what this *h* is doing
here. It looks like *h* conveys *g (x:)* from last time into the next
application.
Did I miss something when I think about doing fold with function as
accumulator?

I'd really appreciate if anyone could help me with this.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20200807/44735383/attachment.html>

From bob at redivi.com  Sat Aug  8 05:24:57 2020
From: bob at redivi.com (Bob Ippolito)
Date: Fri, 7 Aug 2020 22:24:57 -0700
Subject: [Haskell-beginners] Understanding functions like f a b c = c $
	b a
In-Reply-To: <CAM2mjt_y2=rT_Gz3VWH+e1xb+A1US+KoaKvHS1TskrPM3BxTPw@mail.gmail.com>
References: <CAM2mjt_y2=rT_Gz3VWH+e1xb+A1US+KoaKvHS1TskrPM3BxTPw@mail.gmail.com>
Message-ID: <CACwMPm98kn_p4GiMdmPgWPY-jPqShynEU8TgVtk6989vxCHttg@mail.gmail.com>

I think the part that is confusing is that there are two steps here, there
is the *foldr*, and then there is the application of *id* to the result of
the *foldr*. *foldr* is of type *(a -> b -> b) -> b -> [a] -> b*, and in
your example the type for *a* is *Integer* (probably not precisely Integer,
but let's just say it is for simplicity) and the type for *b* is *[Integer]
-> [Integer]*. It would be better to think of it as *(foldr f (const [])
xs) id*. Another way to think of it is that *foldr* replaces the list *:*
constructor with the function (*f*) and the *[]* constructor with the given
*b* (*id*). Here's how I would think about the computation. In Haskell it's
usually best to start with the outside and work in, due to the non-strict
evaluation. At the end I've removed the bold from the terms that are
already completely reduced.

*init' [1, 2, 3]*
*(foldr f (const []) (1 : 2 : 3 : [])) id*
*(1 `f` (2 `f` (3 `f` const []))) id*
*id ((2 `f` (3 `f` const [])) (1:))*

*(2 `f` (3 `f` const [])) (1:)*
1 :* ((3 `f` const []) (2:))*
1 : 2 :* (const [] (3:))*
1 : 2 : []


On Fri, Aug 7, 2020 at 7:12 AM Austin Zhu <austinzhu666 at gmail.com> wrote:

> Hello!
>
> I'm learning Haskell and I found an interesting implementation of init
> using foldr. However I have difficulty understand how it works.
>
> *init' xs = foldr f (const []) xs id*
> *    where f x g h = h $ g (x:)*
>
> Consider I have a input of *[1,2,3]*, then is would become
>
> *f 1 (f 2 ( f 3 (const []))) id*
>
> I substitute those parameters into f and the innermost one becomes *h $
> (const []) (1:)*, which is simply *h []*. However when I want to reduce
> the expression further, I found it's hard to grasp. The next one becomes *f
> 2 (h [])* , which is
>
> *h $ (h []) (2:)*
>
> if it works like that. This looks confusing to me. To match the type of
> *foldr*, h should be of type *[a] -> [a]* and *h []* would just be of
> type *[a]*, which isn't applicable to *(2:)*.
>
> I also thought it in another way that *f x g* returns a function of type *([a]
> -> [a]) -> [a],* this kinda makes sense considering applying *id*
> afterwards. But then I realized I still don't know what this *h* is doing
> here. It looks like *h* conveys *g (x:)* from last time into the next
> application.
> Did I miss something when I think about doing fold with function as
> accumulator?
>
> I'd really appreciate if anyone could help me with this.
> _______________________________________________
> 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/20200807/fb6da7bf/attachment.html>

From fa-ml at ariis.it  Sat Aug  8 11:24:37 2020
From: fa-ml at ariis.it (Francesco Ariis)
Date: Sat, 8 Aug 2020 13:24:37 +0200
Subject: [Haskell-beginners] Understanding functions like f a b c = c $
 b a
In-Reply-To: <CACwMPm98kn_p4GiMdmPgWPY-jPqShynEU8TgVtk6989vxCHttg@mail.gmail.com>
References: <CAM2mjt_y2=rT_Gz3VWH+e1xb+A1US+KoaKvHS1TskrPM3BxTPw@mail.gmail.com>
 <CACwMPm98kn_p4GiMdmPgWPY-jPqShynEU8TgVtk6989vxCHttg@mail.gmail.com>
Message-ID: <20200808112437.GA15774@extensa>

+1

Il 07 agosto 2020 alle 22:24 Bob Ippolito ha scritto:
> I think the part that is confusing is that there are two steps here, there
> is the *foldr*, and then there is the application of *id* to the result of
> the *foldr*. *foldr* is of type *(a -> b -> b) -> b -> [a] -> b*, and in
> your example the type for *a* is *Integer* (probably not precisely Integer,
> but let's just say it is for simplicity) and the type for *b* is *[Integer]
> -> [Integer]*. It would be better to think of it as *(foldr f (const [])
> xs) id*. Another way to think of it is that *foldr* replaces the list *:*
> constructor with the function (*f*) and the *[]* constructor with the given
> *b* (*id*). Here's how I would think about the computation. In Haskell it's
> usually best to start with the outside and work in, due to the non-strict
> evaluation. At the end I've removed the bold from the terms that are
> already completely reduced.
> 
> *init' [1, 2, 3]*
> *(foldr f (const []) (1 : 2 : 3 : [])) id*
> *(1 `f` (2 `f` (3 `f` const []))) id*
> *id ((2 `f` (3 `f` const [])) (1:))*
> 
> *(2 `f` (3 `f` const [])) (1:)*
> 1 :* ((3 `f` const []) (2:))*
> 1 : 2 :* (const [] (3:))*
> 1 : 2 : []
> 
> 
> On Fri, Aug 7, 2020 at 7:12 AM Austin Zhu <austinzhu666 at gmail.com> wrote:
> 
> > Hello!
> >
> > I'm learning Haskell and I found an interesting implementation of init
> > using foldr. However I have difficulty understand how it works.
> >
> > *init' xs = foldr f (const []) xs id*
> > *    where f x g h = h $ g (x:)*
> >
> > Consider I have a input of *[1,2,3]*, then is would become
> >
> > *f 1 (f 2 ( f 3 (const []))) id*
> >
> > I substitute those parameters into f and the innermost one becomes *h $
> > (const []) (1:)*, which is simply *h []*. However when I want to reduce
> > the expression further, I found it's hard to grasp. The next one becomes *f
> > 2 (h [])* , which is
> >
> > *h $ (h []) (2:)*
> >
> > if it works like that. This looks confusing to me. To match the type of
> > *foldr*, h should be of type *[a] -> [a]* and *h []* would just be of
> > type *[a]*, which isn't applicable to *(2:)*.
> >
> > I also thought it in another way that *f x g* returns a function of type *([a]
> > -> [a]) -> [a],* this kinda makes sense considering applying *id*
> > afterwards. But then I realized I still don't know what this *h* is doing
> > here. It looks like *h* conveys *g (x:)* from last time into the next
> > application.
> > Did I miss something when I think about doing fold with function as
> > accumulator?
> >
> > I'd really appreciate if anyone could help me with this.
> > _______________________________________________
> > 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


From fa-ml at ariis.it  Sat Aug  8 11:37:42 2020
From: fa-ml at ariis.it (Francesco Ariis)
Date: Sat, 8 Aug 2020 13:37:42 +0200
Subject: [Haskell-beginners] Understanding functions like f a b c = c $
 b a
In-Reply-To: <20200808112437.GA15774@extensa>
References: <CAM2mjt_y2=rT_Gz3VWH+e1xb+A1US+KoaKvHS1TskrPM3BxTPw@mail.gmail.com>
 <CACwMPm98kn_p4GiMdmPgWPY-jPqShynEU8TgVtk6989vxCHttg@mail.gmail.com>
 <20200808112437.GA15774@extensa>
Message-ID: <20200808113742.GA22015@extensa>

Il 08 agosto 2020 alle 13:24 Francesco Ariis ha scritto:
> +1

This is silly me thinking I was replying to a Discourse thread liking
the post…

From austinzhu666 at gmail.com  Sat Aug  8 16:06:33 2020
From: austinzhu666 at gmail.com (Austin Zhu)
Date: Sun, 9 Aug 2020 01:06:33 +0900
Subject: [Haskell-beginners] Understanding functions like f a b c = c $
	b a
In-Reply-To: <CACwMPm98kn_p4GiMdmPgWPY-jPqShynEU8TgVtk6989vxCHttg@mail.gmail.com>
References: <CAM2mjt_y2=rT_Gz3VWH+e1xb+A1US+KoaKvHS1TskrPM3BxTPw@mail.gmail.com>
 <CACwMPm98kn_p4GiMdmPgWPY-jPqShynEU8TgVtk6989vxCHttg@mail.gmail.com>
Message-ID: <CAM2mjt-s5NxU0qcVP2oUDo4RYF_+R58C-7uya=y+P2XSiz+OPw@mail.gmail.com>

Thank you for replying! It becomes a lot clearer now. :-)

On Sat, Aug 8, 2020, 14:25 Bob Ippolito <bob at redivi.com> wrote:

> I think the part that is confusing is that there are two steps here, there
> is the *foldr*, and then there is the application of *id* to the result
> of the *foldr*. *foldr* is of type *(a -> b -> b) -> b -> [a] -> b*, and
> in your example the type for *a* is *Integer* (probably not precisely
> Integer, but let's just say it is for simplicity) and the type for *b* is *[Integer]
> -> [Integer]*. It would be better to think of it as *(foldr f (const [])
> xs) id*. Another way to think of it is that *foldr* replaces the list *:*
> constructor with the function (*f*) and the *[]* constructor with the
> given *b* (*id*). Here's how I would think about the computation. In
> Haskell it's usually best to start with the outside and work in, due to the
> non-strict evaluation. At the end I've removed the bold from the terms that
> are already completely reduced.
>
> *init' [1, 2, 3]*
> *(foldr f (const []) (1 : 2 : 3 : [])) id*
> *(1 `f` (2 `f` (3 `f` const []))) id*
> *id ((2 `f` (3 `f` const [])) (1:))*
>
> *(2 `f` (3 `f` const [])) (1:)*
> 1 :* ((3 `f` const []) (2:))*
> 1 : 2 :* (const [] (3:))*
> 1 : 2 : []
>
>
> On Fri, Aug 7, 2020 at 7:12 AM Austin Zhu <austinzhu666 at gmail.com> wrote:
>
>> Hello!
>>
>> I'm learning Haskell and I found an interesting implementation of init
>> using foldr. However I have difficulty understand how it works.
>>
>> *init' xs = foldr f (const []) xs id*
>> *    where f x g h = h $ g (x:)*
>>
>> Consider I have a input of *[1,2,3]*, then is would become
>>
>> *f 1 (f 2 ( f 3 (const []))) id*
>>
>> I substitute those parameters into f and the innermost one becomes *h $
>> (const []) (1:)*, which is simply *h []*. However when I want to reduce
>> the expression further, I found it's hard to grasp. The next one becomes *f
>> 2 (h [])* , which is
>>
>> *h $ (h []) (2:)*
>>
>> if it works like that. This looks confusing to me. To match the type of
>> *foldr*, h should be of type *[a] -> [a]* and *h []* would just be of
>> type *[a]*, which isn't applicable to *(2:)*.
>>
>> I also thought it in another way that *f x g* returns a function of type *([a]
>> -> [a]) -> [a],* this kinda makes sense considering applying *id*
>> afterwards. But then I realized I still don't know what this *h* is
>> doing here. It looks like *h* conveys *g (x:)* from last time into the
>> next application.
>> Did I miss something when I think about doing fold with function as
>> accumulator?
>>
>> I'd really appreciate if anyone could help me with this.
>> _______________________________________________
>> 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/20200809/0b339c0e/attachment.html>

From ky3 at atamo.com  Mon Aug 10 01:00:10 2020
From: ky3 at atamo.com (Kim-Ee Yeoh)
Date: Mon, 10 Aug 2020 08:00:10 +0700
Subject: [Haskell-beginners] Understanding functions like f a b c = c $
	b a
In-Reply-To: <CAM2mjt_y2=rT_Gz3VWH+e1xb+A1US+KoaKvHS1TskrPM3BxTPw@mail.gmail.com>
References: <CAM2mjt_y2=rT_Gz3VWH+e1xb+A1US+KoaKvHS1TskrPM3BxTPw@mail.gmail.com>
Message-ID: <CAPY+ZdSFmxPtT_ACtt-EtGSVmqoTuDgcfbLqJouSXMuR+FDN=w@mail.gmail.com>

On Fri, Aug 7, 2020 at 9:12 PM Austin Zhu <austinzhu666 at gmail.com> wrote:

> Hello!
>
> I'm learning Haskell and I found an interesting implementation of init
> using foldr. However I have difficulty understand how it works.
>
> *init' xs = foldr f (const []) xs id*
> *    where f x g h = h $ g (x:)*
>
> Consider I have a input of *[1,2,3]*, then is would become
>
> *f 1 (f 2 ( f 3 (const []))) id*
>
> I substitute those parameters into f and the innermost one becomes *h $
> (const []) (1:)*, which is simply *h []*. However when I want to reduce
> the expression further, I found it's hard to grasp. The next one becomes *f
> 2 (h [])* , which is
>
> *h $ (h []) (2:)*
>
>
The last line isn’t correct because of erroneous alpha capture.

Modulo certain things that aren’t relevant here, the definition of the
folding function f is equivalent to the eta-expansion: f x g = \h -> h (g
(x:)). Note the lambda abstraction.

Try substituting that in

*f 1 (f 2 ( f 3 (const []))) id*

to see what you get.

Hint: Note how f 3 (const []) evaluates to

\h -> h (const [] (3:))
= \h -> h []
= ($ [])

Next f 2 ($ []) becomes

\h -> h (($ []) (2:))
= \h -> h (2:[])
= ($ (2:[]))

And you can see how you end up with init’ [1,2,3] = 1:(2:[]) = [1,2].
Notice how I converted from a lambda abstraction to combinator form to
prevent the named lambda variable h from obscuring what’s really going on.

Another way to figure out this out is by calculating the precise type of
the folding function f that is provided to foldr and hence the type to h.


if it works like that. This looks confusing to me. To match the type of
> *foldr*, h should be of type *[a] -> [a]* and *h []* would just be of
> type *[a]*, which isn't applicable to *(2:)*.
>
> I also thought it in another way that *f x g* returns a function of type *([a]
> -> [a]) -> [a],* this kinda makes sense considering applying *id*
> afterwards. But then I realized I still don't know what this *h* is doing
> here. It looks like *h* conveys *g (x:)* from last time into the next
> application.
> Did I miss something when I think about doing fold with function as
> accumulator?
>
> I'd really appreciate if anyone could help me with this.
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
-- 
-- Kim-Ee
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20200810/032dd823/attachment.html>

From fa-ml at ariis.it  Mon Aug 10 01:05:59 2020
From: fa-ml at ariis.it (Francesco Ariis)
Date: Mon, 10 Aug 2020 03:05:59 +0200
Subject: [Haskell-beginners] Understanding functions like f a b c = c $
 b a
In-Reply-To: <CAPY+ZdSFmxPtT_ACtt-EtGSVmqoTuDgcfbLqJouSXMuR+FDN=w@mail.gmail.com>
References: <CAM2mjt_y2=rT_Gz3VWH+e1xb+A1US+KoaKvHS1TskrPM3BxTPw@mail.gmail.com>
 <CAPY+ZdSFmxPtT_ACtt-EtGSVmqoTuDgcfbLqJouSXMuR+FDN=w@mail.gmail.com>
Message-ID: <20200810010559.GA1732@extensa>

+1

Il 10 agosto 2020 alle 08:00 Kim-Ee Yeoh ha scritto:
> On Fri, Aug 7, 2020 at 9:12 PM Austin Zhu <austinzhu666 at gmail.com> wrote:
> 
> > Hello!
> >
> > I'm learning Haskell and I found an interesting implementation of init
> > using foldr. However I have difficulty understand how it works.
> >
> > *init' xs = foldr f (const []) xs id*
> > *    where f x g h = h $ g (x:)*
> >
> > Consider I have a input of *[1,2,3]*, then is would become
> >
> > *f 1 (f 2 ( f 3 (const []))) id*
> >
> > I substitute those parameters into f and the innermost one becomes *h $
> > (const []) (1:)*, which is simply *h []*. However when I want to reduce
> > the expression further, I found it's hard to grasp. The next one becomes *f
> > 2 (h [])* , which is
> >
> > *h $ (h []) (2:)*
> >
> >
> The last line isn’t correct because of erroneous alpha capture.
> 
> Modulo certain things that aren’t relevant here, the definition of the
> folding function f is equivalent to the eta-expansion: f x g = \h -> h (g
> (x:)). Note the lambda abstraction.
> 
> Try substituting that in
> 
> *f 1 (f 2 ( f 3 (const []))) id*
> 
> to see what you get.
> 
> Hint: Note how f 3 (const []) evaluates to
> 
> \h -> h (const [] (3:))
> = \h -> h []
> = ($ [])
> 
> Next f 2 ($ []) becomes
> 
> \h -> h (($ []) (2:))
> = \h -> h (2:[])
> = ($ (2:[]))
> 
> And you can see how you end up with init’ [1,2,3] = 1:(2:[]) = [1,2].
> Notice how I converted from a lambda abstraction to combinator form to
> prevent the named lambda variable h from obscuring what’s really going on.
> 
> Another way to figure out this out is by calculating the precise type of
> the folding function f that is provided to foldr and hence the type to h.
> 
> 
> if it works like that. This looks confusing to me. To match the type of
> > *foldr*, h should be of type *[a] -> [a]* and *h []* would just be of
> > type *[a]*, which isn't applicable to *(2:)*.
> >
> > I also thought it in another way that *f x g* returns a function of type *([a]
> > -> [a]) -> [a],* this kinda makes sense considering applying *id*
> > afterwards. But then I realized I still don't know what this *h* is doing
> > here. It looks like *h* conveys *g (x:)* from last time into the next
> > application.
> > Did I miss something when I think about doing fold with function as
> > accumulator?
> >
> > I'd really appreciate if anyone could help me with this.
> > _______________________________________________
> > Beginners mailing list
> > Beginners at haskell.org
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> >
> -- 
> -- Kim-Ee

> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners


From alexander at chenjia.nl  Thu Aug 13 11:02:19 2020
From: alexander at chenjia.nl (Alexander Chen)
Date: Thu, 13 Aug 2020 13:02:19 +0200 (CEST)
Subject: [Haskell-beginners] IO operations
Message-ID: <252977439.222507.1597316539010@ichabod.co-bxl>

Hi,

module Main where

allwords :: IO Int
allwords  = do
    dict <- readFile "data/dict.txt"
    return  $ length [x | x <- dict , not $ '-' `elem` x]
    
main :: IO Int
main = do allwords

error

* Couldn't match expected type `t0 Char' with actual type `Char'
* In the second argument of `elem', namely `x'
  In the second argument of `($)', namely '-' `elem` x
  In the expression: not $ '-' `elem` x

could someone tell me what I am doing wrong?

thanks!
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20200813/af2c8f4c/attachment.html>

From fa-ml at ariis.it  Thu Aug 13 11:19:26 2020
From: fa-ml at ariis.it (Francesco Ariis)
Date: Thu, 13 Aug 2020 13:19:26 +0200
Subject: [Haskell-beginners] IO operations
In-Reply-To: <252977439.222507.1597316539010@ichabod.co-bxl>
References: <252977439.222507.1597316539010@ichabod.co-bxl>
Message-ID: <20200813111926.GC2065@extensa>

Hello Alexander

Il 13 agosto 2020 alle 13:02 Alexander Chen ha scritto:
> allwords :: IO Int
> allwords  = do
>     dict <- readFile "data/dict.txt"
>     return  $ length [x | x <- dict , not $ '-' `elem` x]

`elem` has type:

    λ> :t elem
    elem :: Eq a => a -> [a] -> Bool
    -- almost

You are comparing '-' (a `Char`) with `x` (another `Char`), hence you
only need `==`. Does this make sense?
—F

From alexander at klink.name  Thu Aug 13 11:24:00 2020
From: alexander at klink.name (Alexander Klink)
Date: Thu, 13 Aug 2020 13:24:00 +0200
Subject: [Haskell-beginners] IO operations
In-Reply-To: <252977439.222507.1597316539010@ichabod.co-bxl>
References: <252977439.222507.1597316539010@ichabod.co-bxl>
Message-ID: <20200813112400.GN20834@putna.0x90.eu>


On Thu, Aug 13, 2020 at 01:02:19PM +0200, Alexander Chen wrote:
> module Main where
> 
> allwords :: IO Int
> allwords  = do
>     dict <- readFile "data/dict.txt"
>     return  $ length [x | x <- dict , not $ '-' `elem` x]
>     
> main :: IO Int
> main = do allwords
> 
> error
> 
> * Couldn't match expected type `t0 Char' with actual type `Char'
> * In the second argument of `elem', namely `x'
>   In the second argument of `($)', namely '-' `elem` x
>   In the expression: not $ '-' `elem` x
> 
> could someone tell me what I am doing wrong?

dict is of type String, since it's a String containing the complete
file. That's why the type complaint is that you want to check if '-' (a
Char) is an element of x, which is also a Char, which cannot work.

I asssume what you want is a list of lines, which you can by
applying the lines function, e.g. here:

     return  $ length [x | x <- lines dict , not $ '-' `elem` x]

HTH,
Cheers,
Alex

From to_br at uni-bremen.de  Thu Aug 13 11:14:39 2020
From: to_br at uni-bremen.de (Tobias Brandt)
Date: Thu, 13 Aug 2020 13:14:39 +0200
Subject: [Haskell-beginners] IO operations
In-Reply-To: <252977439.222507.1597316539010@ichabod.co-bxl>
References: <252977439.222507.1597316539010@ichabod.co-bxl>
Message-ID: <778b310a-184c-f604-491d-7e74bb3dee08@uni-bremen.de>

Hey Alexander,

|dict| has type |String|. Therefore, |x| is of type |Char|, but |elem 
'-'| is of type |[Char] -> Bool| (simplified). Hence, you get a type 
mismatch. If you just want to count every character except |'-'|, then 
you could just you |'-' /= x|.

Cheers

Tobias

On 8/13/20 1:02 PM, Alexander Chen wrote:
> Hi,
>
> module Main where
> allwords :: IO Int
> allwords  = do
>     dict <- readFile "data/dict.txt"
>     return  $ length [x | x <- dict , not $ '-' `elem` x]
> main :: IO Int
> main = do allwords
>
> error
>
> * Couldn't match expected type `t0 Char' with actual type `Char'
> * In the second argument of `elem', namely `x'
>   In the second argument of `($)', namely '-' `elem` x
>   In the expression: not $ '-' `elem` x
>
>
> could someone tell me what I am doing wrong?
>
> thanks!
>
> _______________________________________________
> 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/20200813/98839a35/attachment.html>

From traqueofziche at gmail.com  Fri Aug 14 01:23:02 2020
From: traqueofziche at gmail.com (=?UTF-8?B?6bKN5Yev5paH?=)
Date: Thu, 13 Aug 2020 18:23:02 -0700
Subject: [Haskell-beginners] IO operations
In-Reply-To: <mailman.7.1597320002.31001.beginners@haskell.org>
References: <mailman.7.1597320002.31001.beginners@haskell.org>
Message-ID: <CAMjcG+ETZeHz66EP0Axqxa4YgSLX-G9N89m7Mcc_G7604YjRmA@mail.gmail.com>

Hi,

> * Couldn't match expected type `t0 Char' with actual type `Char'
> * In the second argument of `elem', namely `x'
>   In the second argument of `($)', namely '-' `elem` x
>   In the expression: not $ '-' `elem` x

Hope the other answers helped. FWIW, just wanted to point out that for me
these kinds of error messages sometimes used to be confusing since the type
of `elem` is `(Foldable t, Eq a) => a -> t a -> Bool`, so the typechecker
tells you it wants to unify `t0 Char` (where `t0` is something `Foldable`)
with `Char`. As Mr. Klink wrote, it looks like you wanted `t0` to be `[]`;
I used to get confused since I was only working with lists and the extra
`Foldable` genericity made it harder to see that I was still just working
with lists.

Best,

toz

>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20200813/fc5ac250/attachment.html>

From alexander at chenjia.nl  Wed Aug 19 13:41:38 2020
From: alexander at chenjia.nl (Alexander Chen)
Date: Wed, 19 Aug 2020 15:41:38 +0200 (CEST)
Subject: [Haskell-beginners] Text.Regex.Posix
Message-ID: <81146234.623150.1597844498292@ichabod.co-bxl>



Hi,

cabal install regex-posix

runs without issue.

added it to cabal dependencies:

name:                data-regex
version:             0.1.0.0
-- synopsis:
-- description:
homepage:            https://github.com/githubuser/data-regex#readme
license:             BSD3
license-file:        LICENSE
author:              Alexander Chen
maintainer:          example at example.com
copyright:           2020 Alexander Chen
category:            regex
build-type:          Simple
cabal-version:       >=1.10
extra-source-files:  README.md

executable data-regex
  hs-source-dirs:      src
  main-is:             Main.hs
  default-language:    Haskell2010
  build-depends:       base >= 4.7 && < 5, regex-posix 

Then I do:

stack install regex-posix

error>
WARNING: Ignoring regex-posix's bounds on base (<0 && >=4.3 && <4.15); using base-4.13.0.0.
Reason: trusting snapshot over cabal file dependency information.
regex-posix> configure
regex-posix> Configuring regex-posix-0.96.0.0...
regex-posix> build
regex-posix> Preprocessing library for regex-posix-0.96.0.0..
regex-posix> C:\Users\achen\AppData\Local\Temp\stack-e2b99a8a9eb45aea\regex-posix-0.96.0.0\Wrap.hsc:96:10: fatal error: regex.h: No such file or directory
regex-posix> compilation terminated.
regex-posix> compiling .stack-work\dist\29cc6475\build\Text\Regex\Posix\Wrap_hsc_make.c failed (exit code 1)
regex-posix> command was: C:\Users\achen\AppData\Local\Programs\stack\x86_64-windows\ghc-8.8.3\lib\../mingw/bin\gcc.exe -c .stack-work\dist\29cc6475\build\Text\Regex\Posix\Wrap_hsc_make.c -o .stack-work\dist\29cc6475\build\Text\Regex\Posix\Wrap_hsc_make.o -D__GLASGOW_HASKELL__=808 -Dmingw32_BUILD_OS=1 -Dx86_64_BUILD_ARCH=1 -Dmingw32_HOST_OS=1 -Dx86_64_HOST_ARCH=1 -Icbits -IC:\Users\achen\AppData\Local\Programs\stack\x86_64-windows\msys2-20180531\mingw64\include -I.stack-work\dist\29cc6475\build\cbits -IC:\Users\achen\AppData\Local\Programs\stack\x86_64-windows\msys2-20180531\mingw64\include -I.stack-work\dist\29cc6475\build\autogen -I.stack-work\dist\29cc6475\build\global-autogen -include .stack-work\dist\29cc6475\build\autogen\cabal_macros.h -IC:\Users\achen\AppData\Local\Programs\stack\x86_64-windows\msys2-20180531\mingw64\include -IC:\Users\achen\AppData\Local\Programs\stack\x86_64-windows\ghc-8.8.3\lib\bytestring-0.10.10.0\include -IC:\Users\achen\AppData\Local\Programs\stack\x86_64-windows\ghc-8.8.3\lib\base-4.13.0.0\include -IC:\Users\achen\AppData\Local\Programs\stack\x86_64-windows\ghc-8.8.3\lib\integer-gmp-1.0.2.0\include -IC:\Users\achen\AppData\Local\Programs\stack\x86_64-windows\ghc-8.8.3\lib/include -IC:\Users\achen\AppData\Local\Programs\stack\x86_64-windows\ghc-8.8.3/lib/include/

--  While building package regex-posix-0.96.0.0 using:
      C:\sr\setup-exe-cache\x86_64-windows\Cabal-simple_Z6RU0evB_3.0.1.0_ghc-8.8.3.exe --builddir=.stack-work\dist\29cc6475 build --ghc-options " -fdiagnostics-color=always"      
    Process exited with code: ExitFailure 1
Progress 1/2

=========================================================================================================================================================================================

I also get an error in my main(but seems related):

module Main where

import Text.Regex.Posix

main :: IO ()
main = do
  let str1 = "one fish two fish red fish blue fish"
  let str2 = "The quick brown fox jumps over the lazy dog."
  print str1 =~ "one" ::Bool

What am I doing wrong?

best,
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20200819/63c18eee/attachment.html>

From joshuatfriedlander at gmail.com  Thu Aug 20 19:02:21 2020
From: joshuatfriedlander at gmail.com (Josh Friedlander)
Date: Thu, 20 Aug 2020 22:02:21 +0300
Subject: [Haskell-beginners] Clarifying $ vs parentheses
Message-ID: <CAC2wD73M1h9SkgOLJJnp4USVT0T4MxVHYe9qKbUKV4p6GDmBYA@mail.gmail.com>

I understand that in general $ is a) right-associative and b)
lowest-priority. But if so shouldn't these two be roughly the same?

λ take (succ 10) $ cycle "hello world"
"hello world"

But not this?
λ take $ succ 10 $ cycle "hello world"

<interactive>:20:8: error:
    • No instance for (Enum ([Char] -> Int))
        arising from a use of ‘succ’
        (maybe you haven't applied a function to enough arguments?)
    • In the expression: succ 10
      In the second argument of ‘($)’, namely
        ‘succ 10 $ cycle "hello world"’
      In the expression: take $ succ 10 $ cycle "hello world"

<interactive>:20:13: error:
    • No instance for (Num ([Char] -> Int))
        arising from the literal ‘10’
        (maybe you haven't applied a function to enough arguments?)
    • In the first argument of ‘succ’, namely ‘10’
      In the expression: succ 10
      In the second argument of ‘($)’, namely
        ‘succ 10 $ cycle "hello world"’
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20200820/60226e97/attachment.html>

From bob at redivi.com  Thu Aug 20 19:36:24 2020
From: bob at redivi.com (Bob Ippolito)
Date: Thu, 20 Aug 2020 12:36:24 -0700
Subject: [Haskell-beginners] Clarifying $ vs parentheses
In-Reply-To: <CAC2wD73M1h9SkgOLJJnp4USVT0T4MxVHYe9qKbUKV4p6GDmBYA@mail.gmail.com>
References: <CAC2wD73M1h9SkgOLJJnp4USVT0T4MxVHYe9qKbUKV4p6GDmBYA@mail.gmail.com>
Message-ID: <CACwMPm9wuU-6okWXQtit8ULAD-rVnikSkZGnCTtb-ZUz1vDq4A@mail.gmail.com>

Because the second one is:

  take (succ 10 (cycle “hello world”))

On Thu, Aug 20, 2020 at 12:03 Josh Friedlander <joshuatfriedlander at gmail.com>
wrote:

> I understand that in general $ is a) right-associative and b)
> lowest-priority. But if so shouldn't these two be roughly the same?
>
> λ take (succ 10) $ cycle "hello world"
> "hello world"
>
> But not this?
> λ take $ succ 10 $ cycle "hello world"
>
> <interactive>:20:8: error:
>     • No instance for (Enum ([Char] -> Int))
>         arising from a use of ‘succ’
>         (maybe you haven't applied a function to enough arguments?)
>     • In the expression: succ 10
>       In the second argument of ‘($)’, namely
>         ‘succ 10 $ cycle "hello world"’
>       In the expression: take $ succ 10 $ cycle "hello world"
>
> <interactive>:20:13: error:
>     • No instance for (Num ([Char] -> Int))
>         arising from the literal ‘10’
>         (maybe you haven't applied a function to enough arguments?)
>     • In the first argument of ‘succ’, namely ‘10’
>       In the expression: succ 10
>       In the second argument of ‘($)’, namely
>         ‘succ 10 $ cycle "hello world"’
>
>
> _______________________________________________
>
> 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/20200820/0697da5d/attachment.html>

From fa-ml at ariis.it  Thu Aug 20 19:40:31 2020
From: fa-ml at ariis.it (Francesco Ariis)
Date: Thu, 20 Aug 2020 21:40:31 +0200
Subject: [Haskell-beginners] Clarifying $ vs parentheses
In-Reply-To: <CAC2wD73M1h9SkgOLJJnp4USVT0T4MxVHYe9qKbUKV4p6GDmBYA@mail.gmail.com>
References: <CAC2wD73M1h9SkgOLJJnp4USVT0T4MxVHYe9qKbUKV4p6GDmBYA@mail.gmail.com>
Message-ID: <20200820194031.GA30551@extensa>

Hello Josh,

il 20 agosto 2020 alle 22:02 josh friedlander ha scritto:
> i understand that in general $ is a) right-associative and b)
> lowest-priority. but if so shouldn't these two be roughly the same?
> 
> λ take (succ 10) $ cycle "hello world"
> "hello world"
> 
> But not this?
> λ take $ succ 10 $ cycle "hello world"
> 
> […]

    λ> :info ($)
    ($) :: (a -> b) -> a -> b       -- Defined in ‘GHC.Base’
    infixr 0 $

So, since `$` is right associative, the expression

    take $ succ 10 $ cycle "hello world"

becomes

    take (succ 10 (cycle "hello world"))

`cycle "hello world"` makes sense, `succ 10` makes sense,
`succ 10 anotherArgument` does not.
Even `take someStuff` is probably not what you want, since take is usually
invoked with two arguments.

A useful intuition when you see ($) is `it will evaluate everything on
the right of it first`. This way, `not $ xx yy zz` looks right,
`take $ xx aa yy qq` less so.

Does this help?
—F