Send Beginners mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: The (x:xs) in function parameter is a tuple? (Max Voit)
2. Re: general observation about programming (Dudley Brooks)
3. Folders and sub-folders (Mike Houghton)
4. Re: Folders and sub-folders (Imants Cekusins)
5. Re: general observation about programming (Jeffrey Brown)
----------------------------------------------------------------------
Message: 1
Date: Thu, 25 Feb 2016 16:14:05 +0100
From: Max Voit <[email protected]>
To: [email protected]
Subject: Re: [Haskell-beginners] The (x:xs) in function parameter is a
tuple?
Message-ID: <[email protected]>
Content-Type: text/plain; charset=US-ASCII
On Thu, 25 Feb 2016 07:49:56 +0800
Nan Xiao <[email protected]> wrote:
> Rein referred "A tuple can have any number of elements", while Graham
> referred "There's no "one-ple", or 1-tuple, in Haskell.". So which one
> is right? The tuple at least contains 2 elements?
There is no one-tuple; however, there's a zero-tuple. Also no arbitrary
number of tuple elements allowed, due to definition (we're at 61 for
some reason). Refer to
http://hackage.haskell.org/package/ghc-prim-0.4.0.0/docs/GHC-Tuple.html
best, Max
------------------------------
Message: 2
Date: Thu, 25 Feb 2016 08:17:45 -0800
From: Dudley Brooks <[email protected]>
To: [email protected]
Subject: Re: [Haskell-beginners] general observation about programming
Message-ID: <[email protected]>
Content-Type: text/plain; charset="windows-1252"; Format="flowed"
Ages and ages ago I saw this advice about programming:
Q: "What's the best language for a programmer to know?"
A: "English" (or whatever your native language is)
-- Dudley
On 2/24/16 4:03 PM, Dennis Raddle wrote:
> This is more about programming in general than Haskell, although
> Haskellers probably know it well.
>
> I don't claim to have expert knowledge on this, but I'm gradually
> getting better at it.
>
> When I set out to write a program, or refactor a program, or modify a
> program, it helps to set out my thinking in a clear way. And how I
> make it clear is to document my thoughts.
>
> An outline is one good way to organize thoughts and is probably my
> main tool. But good English prose is also helpful.
>
> The key factor is "editing." In what sense do I mean that? Good
> writers do it, and the Haskell documentation does it. I mean (1)
> brevity and (2) good flow. To achieve brevity, you must think about
> the essence of each statement and trim away the unnecessary stuff.
> Good flow refers to how the document builds up and modifies your
> concepts as you read it. A document can actually mirror an effective
> learning process, or influence and change your process.
>
> I work with my documentation, making several editing passes. By the
> time I'm done, I am in a great position to write a concise and
> flexible program.
>
> It's interesting that not only is Haskell a concise language, but the
> Haskell library documentation is concise. Contrast that with the
> Python documentation which often wanders about into areas that are
> irrelevant--it could easily be cut into one third its present size.
>
> Mike
>
>
>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20160225/f9d82223/attachment-0001.html>
------------------------------
Message: 3
Date: Thu, 25 Feb 2016 18:41:20 +0000
From: Mike Houghton <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: [Haskell-beginners] Folders and sub-folders
Message-ID: <[email protected]>
Content-Type: text/plain; charset="utf-8"
Hi,
I?m trying to build up a list of all folders (including subfolders) from a
given root folder.
So I have
folders :: FilePath -> IO [FilePath]
folders fp = do
all <- getDirectoryContents fp
filterM doesDirectoryExist $ map (fp </>) all
and this just gets the immediate folders within the given folder.
I?m stuck on how to recursively call folders and build up the IO [FilePath]
folders :: FilePath -> IO [FilePath]
folders fp = do
all <- getDirectoryContents fp
-- z :: IO [FilePath]
let z = filterM doesDirectoryExist $ map (fp </>) all
? z? :: [FilePath]
z' <- z
? ?? what should happen here?
z : (map folders z?)
Couldn't match expected type ?[FilePath]?
with actual type ?IO [FilePath]?
In the first argument of ?(:)?, namely ?z?
In a stmt of a 'do' block: z : (map folders z')
etc...
Thanks
Mike
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20160225/5d9c88d2/attachment-0001.html>
------------------------------
Message: 4
Date: Thu, 25 Feb 2016 20:07:37 +0100
From: Imants Cekusins <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] Folders and sub-folders
Message-ID:
<CAP1qinaB_Si=phqnyznqharvosr1k_rgesuf+c2etzebovj...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
Hello Mike,
below code find all files recursively from a starting point. It works.
You'd need to tweak it to find folders instead.
import System.Directory
import Data.List
findAllFiles::FilePath -> IO [FilePath]
findAllFiles base0 = gd1 base0
>>= \list1 -> concatMap' recurse3 list1
where gd1 d1 = filter f2 <$> (getDirectoryContents d1)
f2 "." = False
f2 ".." = False
f2 _ = True
recurse3 md3 = doesDirectoryExist md3full
>>= \isDir3 ->
if isDir3 then findAllFiles md3full
else pure [md3full]
where md3full = base0 ++ "/" ++ md3
concatMap':: (a -> IO [b]) -> [a] -> IO [b]
concatMap' m0 list0 = sequence (m0 <$> list0)
>>= \list2 -> pure $ concat list2
------------------------------
Message: 5
Date: Thu, 25 Feb 2016 11:19:24 -0800
From: Jeffrey Brown <[email protected]>
To: [email protected], The Haskell-Beginners Mailing List -
Discussion of primarily beginner-level topics related to Haskell
<[email protected]>
Subject: Re: [Haskell-beginners] general observation about programming
Message-ID:
<CAEc4Ma2DrT0=zMj0wCJPXrZLRJyVpRksexO=ig9krujvqwg...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Something I like about functional programming is how it interfaces with
natural language. Haskell, somehow to a greater extent than other
languages, encourages me to divide functions into one or two-liners. Each
has a type signature that means something in English. Further, each gives
you the opportunity to choose a good name for the function and its
arguments. After doing those things, the function is much easier to write,
and much easier to read -- so much so that often you don't have to read the
function body at all, just the type signature, function name and argument
names.
On Thu, Feb 25, 2016 at 8:17 AM, Dudley Brooks <[email protected]>
wrote:
> Ages and ages ago I saw this advice about programming:
>
> Q: "What's the best language for a programmer to know?"
>
> A: "English" (or whatever your native language is)
>
> -- Dudley
>
>
> On 2/24/16 4:03 PM, Dennis Raddle wrote:
>
> This is more about programming in general than Haskell, although
> Haskellers probably know it well.
>
> I don't claim to have expert knowledge on this, but I'm gradually getting
> better at it.
>
> When I set out to write a program, or refactor a program, or modify a
> program, it helps to set out my thinking in a clear way. And how I make it
> clear is to document my thoughts.
>
> An outline is one good way to organize thoughts and is probably my main
> tool. But good English prose is also helpful.
>
> The key factor is "editing." In what sense do I mean that? Good writers do
> it, and the Haskell documentation does it. I mean (1) brevity and (2) good
> flow. To achieve brevity, you must think about the essence of each
> statement and trim away the unnecessary stuff. Good flow refers to how the
> document builds up and modifies your concepts as you read it. A document
> can actually mirror an effective learning process, or influence and change
> your process.
>
> I work with my documentation, making several editing passes. By the time
> I'm done, I am in a great position to write a concise and flexible program.
>
> It's interesting that not only is Haskell a concise language, but the
> Haskell library documentation is concise. Contrast that with the Python
> documentation which often wanders about into areas that are irrelevant--it
> could easily be cut into one third its present size.
>
> Mike
>
>
>
>
> _______________________________________________
> Beginners mailing
> [email protected]http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
>
--
Jeffrey Benjamin Brown
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20160225/8a114450/attachment.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
[email protected]
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 92, Issue 32
*****************************************
