Send Beginners mailing list submissions to
beginners@haskell.org
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/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: parsing upto n items with parsec (Christian Maeder)
2. Re: is there a best os to easily install external libraries
? (david hodgetts)
3. Re: map question (Will Ness)
4. Re: Re: map question (Deniz Dogan)
5. Re: Re: map question (Brent Yorgey)
6. Re: new locale? (Brent Yorgey)
7. Re: map question (Will Ness)
8. I/O (John Moore)
9. Re: I/O (Daniel Fischer)
10. Re: Re: map question (Daniel Fischer)
----------------------------------------------------------------------
Message: 1
Date: Sat, 17 Oct 2009 11:15:40 +0200
From: Christian Maeder <christian.mae...@dfki.de>
Subject: [Haskell-beginners] Re: parsing upto n items with parsec
To: Ashish Agarwal <agarwal1...@gmail.com>
Cc: beginners@haskell.org
Message-ID: <4ad98b3c.7080...@dfki.de>
Content-Type: text/plain; charset=ISO-8859-1
Ashish Agarwal schrieb:
> Hi. I'm just learning Parsec and Haskell. It is a great library, and I
> see how "many" lets you parse 0 or more items, "many1" parses 1 or more
> items, and "count" parses exactly n items. However, there is no
> combinator that parses between m and n items. What would be the best
> implementation for this?
I would write an "upTo" parser with the same type as "count" that parses
not exactly but at most n items. Your desired parser is than the
concatenated results of "count m p" and "upTo (n - m) p" (achieved by
"liftM2 (++)").
For "upTo" a recursive definition seems best (other may come up with
tricky combinator application.) "upTo 0 p" (or something less than 0)
returns "[]" and "upTo n p" is an "option [] ..." parser of one "p"
result followed by the "upTo (n - 1) p" result:
"option [] (liftM2 (:) p (upTo (n - 1) p))"
HTH Christian
Another possibility is to use "many" and check if the resulting list has
the desired length (if not fail), but that may consume too many tokens
that subsequent parsers are supposed to consume.
------------------------------
Message: 2
Date: Sat, 17 Oct 2009 12:00:23 +0200
From: david hodgetts <david.demainlal...@gmail.com>
Subject: Re: [Haskell-beginners] is there a best os to easily install
external libraries ?
To: beginners@haskell.org
Message-ID:
<42a5d61a0910170300nffb73co2ff69725c9f00...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
Thank you very much for the long and very informative answer. I was going to
try Ubuntu, but since I have a spare machine, I think I will rather "plunge
deep" and try to get arch linux running.
Also, thanks for mentioning andLinux, I will certainly check it out.
best regards
david hodgetts
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
http://www.haskell.org/pipermail/beginners/attachments/20091017/4bf4d21f/attachment-0001.html
------------------------------
Message: 3
Date: Sat, 17 Oct 2009 18:29:39 +0000 (UTC)
From: Will Ness <will_...@yahoo.com>
Subject: [Haskell-beginners] Re: map question
To: beginners@haskell.org
Message-ID: <loom.20091017t202435-...@post.gmane.org>
Content-Type: text/plain; charset=us-ascii
Brent Yorgey <byorgey <at> seas.upenn.edu> writes:
>
> By the way, the reason
>
> map (+1) [1,2,3,4]
>
> works but
>
> map (-1) [1,2,3,4]
>
> doesn't is because of an ugly corner of Haskell syntax: -1 here is
> parsed as negative one, rather than an operator section with
> subtraction. The 'subtract' function is provided exactly for this
> purpose, so that you can write
>
> map (subtract 1) [1,2,3,4]
>
Then why wouldn't (`-`1) parse at at all? And not even (`(-)`1) ?
I know this doesn't parse, my question is, why wouldn't it be made valid
syntax? It seems consistent. (`mod`2) parses, why not (`-`2) ?
------------------------------
Message: 4
Date: Sat, 17 Oct 2009 20:41:30 +0200
From: Deniz Dogan <deniz.a.m.do...@gmail.com>
Subject: Re: [Haskell-beginners] Re: map question
To: Will Ness <will_...@yahoo.com>
Cc: beginners@haskell.org
Message-ID:
<7b501d5c0910171141y56be9da3wa70658d090097...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
2009/10/17 Will Ness <will_...@yahoo.com>:
> Brent Yorgey <byorgey <at> seas.upenn.edu> writes:
>
>>
>> By the way, the reason
>>
>> map (+1) [1,2,3,4]
>>
>> works but
>>
>> map (-1) [1,2,3,4]
>>
>> doesn't is because of an ugly corner of Haskell syntax: -1 here is
>> parsed as negative one, rather than an operator section with
>> subtraction. The 'subtract' function is provided exactly for this
>> purpose, so that you can write
>>
>> map (subtract 1) [1,2,3,4]
>>
>
> Then why wouldn't (`-`1) parse at at all? And not even (`(-)`1) ?
>
> I know this doesn't parse, my question is, why wouldn't it be made valid
> syntax? It seems consistent. (`mod`2) parses, why not (`-`2) ?
>
>
>
>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
`This` syntax is used to make functions work infix, whereas operators
already are infix. For this reason, it wouldn't make much sense to use
`this` syntax (what's that called anyways?) on an operator.
`(-)` would in some sense be the same thing as just "-", since () is
used to make operators prefix and `` is used to make functions infix.
--
Deniz Dogan
------------------------------
Message: 5
Date: Sat, 17 Oct 2009 14:43:36 -0400
From: Brent Yorgey <byor...@seas.upenn.edu>
Subject: Re: [Haskell-beginners] Re: map question
To: beginners@haskell.org
Message-ID: <20091017184336.ga18...@seas.upenn.edu>
Content-Type: text/plain; charset=us-ascii
On Sat, Oct 17, 2009 at 06:29:39PM +0000, Will Ness wrote:
> Brent Yorgey <byorgey <at> seas.upenn.edu> writes:
>
> >
> > By the way, the reason
> >
> > map (+1) [1,2,3,4]
> >
> > works but
> >
> > map (-1) [1,2,3,4]
> >
> > doesn't is because of an ugly corner of Haskell syntax: -1 here is
> > parsed as negative one, rather than an operator section with
> > subtraction. The 'subtract' function is provided exactly for this
> > purpose, so that you can write
> >
> > map (subtract 1) [1,2,3,4]
> >
>
> Then why wouldn't (`-`1) parse at at all? And not even (`(-)`1) ?
>
> I know this doesn't parse, my question is, why wouldn't it be made valid
> syntax? It seems consistent. (`mod`2) parses, why not (`-`2) ?
`backticks` are only for making (prefix) functions into (infix)
operators. - is already an infix operator, so putting it in backticks
would be redundant. As for `(-)`, arbitrary expressions cannot go
inside backticks, and for good reason: what would `(2 `mod`)` parse
as?
However, certainly different choices might have been possible.
-Brent
------------------------------
Message: 6
Date: Sat, 17 Oct 2009 14:45:22 -0400
From: Brent Yorgey <byor...@seas.upenn.edu>
Subject: Re: [Haskell-beginners] new locale?
To: beginners@haskell.org
Message-ID: <20091017184522.ga19...@seas.upenn.edu>
Content-Type: text/plain; charset=us-ascii
On Wed, Oct 14, 2009 at 05:44:34AM +0100, Robert Wills wrote:
> Hello,
>
> http://hackage.haskell.org/package/old-locale-1.0.0.1
>
> says "This package provides the old locale library. For new code, the new
> locale library is recommended."
>
> Does anyone know where I would find the new library?
What locale functions are you trying to use? As far as I can tell,
there actually is no "new locale library" and functions for working
with the locale have been spread across various other libraries as
appropriate.
-Brent
------------------------------
Message: 7
Date: Sun, 18 Oct 2009 11:11:07 +0000 (UTC)
From: Will Ness <will_...@yahoo.com>
Subject: [Haskell-beginners] Re: map question
To: beginners@haskell.org
Message-ID: <loom.20091018t125911...@post.gmane.org>
Content-Type: text/plain; charset=us-ascii
Brent Yorgey <byorgey <at> seas.upenn.edu> writes:
>
> On Sat, Oct 17, 2009 at 06:29:39PM +0000, Will Ness wrote:
> >
> > Then why wouldn't (`-`1) parse at at all? And not even (`(-)`1) ?
> >
> > I know this doesn't parse, my question is, why wouldn't it be made valid
> > syntax? It seems consistent. (`mod`2) parses, why not (`-`2) ?
>
> `backticks` are only for making (prefix) functions into (infix)
> operators. - is already an infix operator, so putting it in backticks
> would be redundant. As for `(-)`, arbitrary expressions cannot go
> inside backticks, and for good reason: what would `(2 `mod`)` parse
> as?
>
> However, certainly different choices might have been possible.
>
> -Brent
>
backticks could've been made no-op for operators. What's so wrong with (`:`[])?
It'd just be the same as (:[]).
Except for `-`, where it would finally provide us with possibility to write a
shortcut for the ugly (flip (-) 1) as (`-`1).
(2`mod`) is a unary operation :: (Integral a) => a -> a. Putting it inside
backticks would require it be a binary infix op, causing a type mis-match.
For (-) it could choose the binary version over the unary.
Or it could stay illegal for the parenthesised expressions, and just made legal
syntax for operators, as (`:`[]).
I don't know how easy or even possible it is to implement; I'm just saying it
makes sense, for me.
------------------------------
Message: 8
Date: Sun, 18 Oct 2009 14:42:35 +0100
From: John Moore <john.moor...@gmail.com>
Subject: [Haskell-beginners] I/O
To: beginners@haskell.org
Message-ID:
<4f7ad1ad0910180642u687317edu64d3eb86a377e...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
Hi,
Could someone please tell me how to check this program. The problem is where
do I find the output? I laod this into ghc and it comes up OK modules
loaded: Main
gchi>
How do I now check if it works or see the result.
Program below (taken from real world haskell)
-- file: ch07/toupper-imp.hs
import System.IO
import Data.Char(toUpper)
main :: IO ()
main = do
inh <- openFile "quux.txt" ReadMode
outh <- openFile "output.txt" WriteMode
mainloop inh outh
hClose inh
hClose outh
mainloop :: Handle -> Handle -> IO ()
mainloop inh outh =
do ineof <- hIsEOF inh
if ineof
then return ()
else do inpStr <- hGetLine inh
hPutStrLn outh (map toUpper inpStr)
mainloop inh outh
John
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
http://www.haskell.org/pipermail/beginners/attachments/20091018/470b6ecc/attachment-0001.html
------------------------------
Message: 9
Date: Sun, 18 Oct 2009 15:56:32 +0200
From: Daniel Fischer <daniel.is.fisc...@web.de>
Subject: Re: [Haskell-beginners] I/O
To: beginners@haskell.org
Message-ID: <200910181556.33520.daniel.is.fisc...@web.de>
Content-Type: text/plain; charset="iso-8859-15"
Am Sonntag 18 Oktober 2009 15:42:35 schrieb John Moore:
> Hi,
> Could someone please tell me how to check this program. The problem is
> where do I find the output? I laod this into ghc and it comes up OK modules
> loaded: Main
> gchi>
>
> How do I now check if it works or see the result.
>
> Program below (taken from real world haskell)
> -- file: ch07/toupper-imp.hs
> import System.IO
> import Data.Char(toUpper)
>
> main :: IO ()
> main = do
> inh <- openFile "quux.txt" ReadMode
> outh <- openFile "output.txt" WriteMode
> mainloop inh outh
> hClose inh
> hClose outh
> mainloop :: Handle -> Handle -> IO ()
> mainloop inh outh =
> do ineof <- hIsEOF inh
> if ineof
> then return ()
> else do inpStr <- hGetLine inh
> hPutStrLn outh (map toUpper inpStr)
> mainloop inh outh
> John
Make sure you have a file quux.txt in your directory, but no valuable file
output.txt.
Load the module, type ":main" or just "main" at the ghci prompt and compare the
then
present file output.txt (if it isn't present, that's bad) to quux.txt (open
both in an
editor). It should be the uppercase version of that.
Or compile it (ghc --make toupper-imp.hs) and run the binary.
------------------------------
Message: 10
Date: Sun, 18 Oct 2009 16:12:56 +0200
From: Daniel Fischer <daniel.is.fisc...@web.de>
Subject: Re: [Haskell-beginners] Re: map question
To: beginners@haskell.org
Cc: Will Ness <will_...@yahoo.com>
Message-ID: <200910181612.57167.daniel.is.fisc...@web.de>
Content-Type: text/plain; charset="iso-8859-1"
Am Sonntag 18 Oktober 2009 13:11:07 schrieb Will Ness:
> Brent Yorgey <byorgey <at> seas.upenn.edu> writes:
> > On Sat, Oct 17, 2009 at 06:29:39PM +0000, Will Ness wrote:
> > > Then why wouldn't (`-`1) parse at at all? And not even (`(-)`1) ?
> > >
> > > I know this doesn't parse, my question is, why wouldn't it be made
> > > valid syntax? It seems consistent. (`mod`2) parses, why not (`-`2) ?
> >
> > `backticks` are only for making (prefix) functions into (infix)
> > operators. - is already an infix operator, so putting it in backticks
> > would be redundant. As for `(-)`, arbitrary expressions cannot go
> > inside backticks, and for good reason: what would `(2 `mod`)` parse
> > as?
> >
> > However, certainly different choices might have been possible.
> >
> > -Brent
>
> backticks could've been made no-op for operators. What's so wrong with
> (`:`[])? It'd just be the same as (:[]).
Makes writing the parser more complicated.
Makes reading code more irritating.
>
> Except for `-`, where it would finally provide us with possibility to write
> a shortcut for the ugly (flip (-) 1) as (`-`1).
That's ugly too.
My favourite is subtract 1.
>
> (2`mod`) is a unary operation :: (Integral a) => a -> a. Putting it inside
> backticks would require it be a binary infix op, causing a type mis-match.
instance (Integral a) => Integral (b -> a) where ...
Evil, yes, but then f `(2 `mod`)` x would type-check.
But anyway, there are operators where a backticked section would type-check:
f `(g `.`)` x
That's not good.
>
> For (-) it could choose the binary version over the unary.
>
> Or it could stay illegal for the parenthesised expressions, and just made
> legal syntax for operators, as (`:`[]).
>
> I don't know how easy or even possible it is to implement; I'm just saying
> it makes sense, for me.
But it has downsides.
------------------------------
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 16, Issue 10
*****************************************
