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:
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:
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:
References:
Message-ID:
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 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:
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:
References:
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 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:
<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:
References:
Message-ID:
Thank you for replying! It becomes a lot clearer now. :-)
On Sat, Aug 8, 2020, 14:25 Bob Ippolito 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 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:
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:
References:
Message-ID:
On Fri, Aug 7, 2020 at 9:12 PM Austin Zhu 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:
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:
References:
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 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:
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:
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:
References:
Message-ID:
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:
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:
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:
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"
: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"
: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:
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:
References:
Message-ID:
Because the second one is:
take (succ 10 (cycle “hello world”))
On Thu, Aug 20, 2020 at 12:03 Josh Friedlander
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"
>
> :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"
>
> :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:
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:
References:
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