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: Some beginning questions for Haskell (Ertugrul Soeylemez)
2. Multidimensional Matrices in Haskell (Mihai Maruseac)
3. Re: Multidimensional Matrices in Haskell (Dave Bayer)
4. modules (Michael Mossey)
5. Re: modules (Michael Snoyman)
6. Re: Dynamic Programming in Haskell (Ali Razavi)
----------------------------------------------------------------------
Message: 1
Date: Wed, 7 Jul 2010 16:08:29 +0200
From: Ertugrul Soeylemez <e...@ertes.de>
Subject: [Haskell-beginners] Re: Some beginning questions for Haskell
To: beginners@haskell.org
Message-ID: <20100707160829.1d96c...@tritium.streitmacht.eu>
Content-Type: text/plain; charset=US-ASCII
Liu shuping <lsp....@gmail.com> wrote:
> I am new to Haskell, currently I am doing .Net development on windows
> platform. I began to know about Haskell for the reason when I knew
> some C# lambda features come from functional language. I am interested
> in Haskell from the very beginning when I saw it.
Hello there and welcome to the Haskell world. First of all, Haskell is
a general purpose language, so you can write any kind of problem. But
of course this is only half of the story.
> For I am really a very beginner, I get some basic questions:
> 1. Can you have some very general information to explain why use
> Haskell or functional language.
There are lots of pages on the WWW explaining "why functional
programming (FP) matters" (this is the name of one of them). To give a
short summary: FP gives you less programming errors, less code to type
and more readable code (to FP programmers, of course). Also modern FP
languages give you sophisticated type systems. Languages like C#, D and
Java approach this, but are far from comparable.
> 2. Is it a right choice of Haskell if I want to develop some geology
> software which mainly doing some huge numerical computation which
> takes long long time?
Probably yes. There are a few libraries for fast numerical
calculations, including bindings to well known number crunching
packages. If your favorite package is not among those, you can easily
make a binding on your own using the foreign function interface. This
is very easy.
Regarding performance: If you used to develop in C#, don't worry too
much. Your Haskell programs will probably be faster.
> 3. How about user interface, is Haskell capable to build application
> with complex user interface? or should I just use Haskell to build the
> core engine and user other language to build the user interface?
There are two major library bindings: Gtk2hs and wxHaskell. You can
use them to build any type of graphical user interface portably.
> 4. Is Haskell cross-platform? I mean if the Haskell source code is
> "code once and build everywhere?"
Much more than C#. In general, unless you use OS-specific functions,
you won't have any portability issues.
> 5. Are there any successful applications built with Haskell? they can
> give me a direct scene of what Haskell can do.
Nothing very big yet. Darcs is an excellent version control system.
GHC is the most mature Haskell compiler. Xmonad is a simple window
manager for X. There is also Frag, a small 3D shooter (essentially a
tech demo). Finally I would mention Happstack, a complete framework for
rapid and safe web development.
Now as I've noted above, this is only half of the story. The Haskell
user base is much smaller than the user bases of the most popular
languages, so there are less libraries and less applications.
One reason for this is that Haskell has a steep learning curve. Many
Haskell programmers find that in the first few days or even weeks they
do much more learning than actual programming. Not that they couldn't
get applications done, but Haskell is all about safety and correctness,
so you want to learn to do it properly instead of just doing it, like
you would in, say, PHP. This is why we say Haskell is valuable to know,
even if you don't use it.
Note that other languages are slowly adopting Haskell concepts. This
can be seen most clearly in Microsoft's F# language. It's nowhere near
Haskell, but you can see a lot of inspiration. It has very similar
syntax, algebraic types, currying and it even employs monadic
computations (they call them computation expressions).
Conclusion: Go ahead and learn Haskell. Then decide for yourself,
whether it's suitable for your project. Don't worry, learning Haskell
will always pay off, even if you don't use it. Also don't fear to use
languages, which are not widely used. Paul Graham has written a nice
anecdote about this [1]. You should definitely read it, it's a true
story.
[1] http://www.paulgraham.com/avg.html
Greets,
Ertugrul
--
nightmare = unsafePerformIO (getWrongWife >>= sex)
http://ertes.de/
------------------------------
Message: 2
Date: Wed, 7 Jul 2010 17:08:48 +0300
From: Mihai Maruseac <mihai.marus...@gmail.com>
Subject: [Haskell-beginners] Multidimensional Matrices in Haskell
To: beginners@haskell.org, haskell <haskell-c...@haskell.org>
Message-ID:
<aanlktilttriwftfdqmsawwuqjx2dgbuuco0kew1nt...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
Hi,
A friend of mine wanted to do some Cellular Automata experiments in
Haskell and was asking me what packages/libraries are there for
multidimensional matrices. I'm interested in both immutable and
mutable ones but I don't want them to be trapped inside a monad of any
kind.
Any hints?
--
MM
------------------------------
Message: 3
Date: Wed, 7 Jul 2010 07:56:47 -0700
From: Dave Bayer <ba...@cpw.math.columbia.edu>
Subject: Re: [Haskell-beginners] Multidimensional Matrices in Haskell
To: Mihai Maruseac <mihai.marus...@gmail.com>
Cc: Haskell-beginners <beginners@haskell.org>
Message-ID: <e59eb79e-045a-4e6d-8d11-09a867fef...@math.columbia.edu>
Content-Type: text/plain; charset=us-ascii
On Jul 7, 2010, at 7:08 AM, Mihai Maruseac wrote:
> I'm interested in both immutable and mutable ones but I don't want them to be
> trapped inside a monad of any kind.
If you want mutable data, you've imposing some serious constraints on the
sequence in which your program can be evaluated. Like death and taxes, you
cannot escape this. Monads are one way to handle this. If you want "plug and
play" they're probably the easiest way to handle this, for any other approach
you're going to have to get very involved in designing an alternative for
yourself.
By "trapped" do you mean that you don't want to write your whole program inside
"do" notation? By analogy, there are some sequence constraints in any program,
and some people would rather express as much of their program as possible using
function composition, rather than naming variables and passing arguments. This
is called "point-free" and if you like this, the pragmatic sweet spot is to
strive for it some but not all of the time.
By analogy, some of us find monads easiest to understand via Kleisli
composition, which is rather obvious, and we are baffled by the axioms used to
present monads in Haskell, which leave no impression whatsoever no matter how
many times one reads them.
At a pragmatic level, monads simply bury some plumbing under the street for
you. Very convenient. If you find yourself still writing everything using "do"
notation, it's because not everything was buried under the street for you.
Specialize the monad further to your setting, with a goal of expressing as much
as possible as Kleisli composition, introduce an infix composition operator for
this, and most of your code should end up composition, not "do" notation. This
is akin to striving for a point-free style in ordinary code.
I found this to be the case, writing parsers to transform text. Parsing is a
classic application of monads, but I was baffled why everyone thought the
parsers inside "do" notation where so pretty. I felt "trapped" as you fear
feeling. But because my return type was invariably ShowS, it was very easy to
write nearly everything as composition, regaining the clean feeling I remember
e.g. from similar code in Bigloo Scheme.
------------------------------
Message: 4
Date: Wed, 07 Jul 2010 09:18:47 -0700
From: Michael Mossey <m...@alumni.caltech.edu>
Subject: [Haskell-beginners] modules
To: Haskell-beginners <beginners@haskell.org>
Message-ID: <4c34a8e7.8060...@alumni.caltech.edu>
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
So I created the following directory structure:
home /MusDoc/MusDoc.hs
home /MusDoc/FromXML.hs
home /MusDoc/Timing.hs
home /Midi/FromMusDoc.hs
I set -i to "home" referred to above, so I import these modules with
commands like
import MusDoc.MusDoc
import Midi.FromMusDoc
etc..
What do I do to import everything in MusDoc via
import MusDoc
?
I suspect this has something to do with packages... don't feel a need to
explain it all---point me to a good explanation and I'll probably figure it
out.
Mike
------------------------------
Message: 5
Date: Wed, 7 Jul 2010 19:38:35 +0300
From: Michael Snoyman <mich...@snoyman.com>
Subject: Re: [Haskell-beginners] modules
To: Michael Mossey <m...@alumni.caltech.edu>
Cc: Haskell-beginners <beginners@haskell.org>
Message-ID:
<aanlktikl681zskpkgbqbr49lmw7zdgcxoqepzefhm...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
On Wed, Jul 7, 2010 at 7:18 PM, Michael Mossey <m...@alumni.caltech.edu>wrote:
> So I created the following directory structure:
>
> home /MusDoc/MusDoc.hs
> home /MusDoc/FromXML.hs
> home /MusDoc/Timing.hs
> home /Midi/FromMusDoc.hs
>
> I set -i to "home" referred to above, so I import these modules with
> commands like
>
> import MusDoc.MusDoc
> import Midi.FromMusDoc
> etc..
>
> What do I do to import everything in MusDoc via
>
> import MusDoc
>
> ?
>
> I suspect this has something to do with packages... don't feel a need to
> explain it all---point me to a good explanation and I'll probably figure it
> out.
>
> Mike
>
>
> You'd need to create a file "MusDoc.hs" which imports all of the other
files, there's no way to automatically import all sub-modules (AFAIK).
Michael
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
http://www.haskell.org/pipermail/beginners/attachments/20100707/fccf9f56/attachment-0001.html
------------------------------
Message: 6
Date: Wed, 7 Jul 2010 12:40:07 -0400
From: Ali Razavi <ali.raz...@gmail.com>
Subject: Re: [Haskell-beginners] Dynamic Programming in Haskell
To: beginners@haskell.org
Message-ID:
<aanlktincugxgp1ykt325cturk1n_0k7r3px6wytd3...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
Thanks a lot for your through and informative response. Your solution is
well-structured and pellucid. The only part I don't understand is in the
definition of Parens:
data Parens = Mul !Cost Dimension Parens Parens
| Matrix Dimension deriving (Show)
What is the exclamation mark in !Cost, and what does it signify?
Ali
> Date: Wed, 07 Jul 2010 11:30:28 +0200
> From: Heinrich Apfelmus <apfel...@quantentunnel.de>
> Subject: [Haskell-beginners] Re: Dynamic Programming in Haskell
> To: beginners@haskell.org
> Message-ID: <i11hfk$82...@dough.gmane.org>
> Content-Type: text/plain; charset=UTF-8; format=flowed
>
> Ali Razavi wrote:
> > In order to practice Haskell, I decided to program some algorithms from
> the
> > CLRS book. Particularly, I tried to implement the Matrix Chain Order from
> > Chapter 15 on Dynamic Programming.
> > Here is my code. It seems to work, however, it looks ugly and it was a
> > nightmare to debug. I appreciate comments about a more elegant solution,
> and
> > generally the best way to implement these kinds of algorithms in Haskell.
> > Style improvement suggestions are also welcome.
>
> Dynamic programming algorithms follow a common pattern:
>
> * Find a suitably small collection of subproblems that can be used to
> solve the original problem
> * Tabulate the solutions to the subproblems, also called *memoization*
>
> These are two separate concerns and, unlike the prototype imperative
> solutions, are best implemented separately.
>
> Thanks to lazy evaluation, memoization can be implemented very elegantly
> in Haskell. First, it should be a higher-order functions and second, you
> don't need to implement a particular order by which the memo table is
> filled, lazy evaluation will figure that out for you. You already know
> the latter trick, but here is another example:
>
> http://article.gmane.org/gmane.comp.lang.haskell.beginners/554
>
>
> But it doesn't stop here: there are very systemic ways to tackle the
> first part of dynamic programming, i.e. to *derive* dynamic programming
> algorithms from just the problem specification! An example and further
> references are given here
>
> http://thread.gmane.org/gmane.comp.lang.haskell.cafe/42316/focus=42320
>
>
> Concerning matrix chain multiplication, here is my implementation. Note
> the use of telling names and algebraic data types; there is no need to
> get lost in a maze of twisty little indexes, all alike.
>
> import Data.List
> import Data.Array
> import Data.Ord
>
> type Dimension = (Int,Int)
> type Cost = Int
> -- data type representing a parenthesization,
> -- caches cost to calculate and dimension of the result matrix
> data Parens = Mul !Cost Dimension Parens Parens
> | Matrix Dimension deriving (Show)
>
> -- retrieve cached vallues
> cost :: Parens -> Cost
> cost (Mul c _ _ _) = c
> cost (Matrix _) = 0
>
> dimension :: Parens -> Dimension
> dimension (Mul _ d _ _) = d
> dimension (Matrix d) = d
>
> -- smart constructor
> mul :: Parens -> Parens -> Parens
> mul x y = Mul (cost x + cost y + n*m*p) (n,p) x y
> where
> (n,m,p) = (fst $ dimension x, snd $ dimension x,
> snd $ dimension y)
>
> -- dynamic programming algorithm
> solve :: [Int] -> Parens
> solve matrices = chain 1 n
> where
> n = length matrices - 1
> dimensions = array (1,n) . zip [1..] $
> zip (init matrices) (tail matrices)
>
> chain = memoize n chain'
> chain' i j
> | i == j = Matrix (dimensions ! i)
> | otherwise = best [mul (chain i k) (chain (k+1) j)
> | k <- [i..j-1] ]
>
> best = minimumBy (comparing cost)
>
> -- memoize a function on a "square" [1..n] x [1..n]
> memoize :: Int -> (Int -> Int -> a) -> (Int -> Int -> a)
> memoize n f = \i j -> table ! (i,j)
> where
> table = array ((1,1),(n,n)) $
> [((i,j), f i j) | i <- [1..n], j <- [1..n]]
>
> Example output:
>
> *Main> cost $ solve [10,100,5,50,1]
> 1750
>
> I didn't need to debug this code, because it's obviously correct. Put
> differently, instead of spending my effort on debugging, I have spent it
> on making the solution elegant.
>
>
> Regards,
> Heinrich Apfelmus
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
http://www.haskell.org/pipermail/beginners/attachments/20100707/bb387340/attachment.html
------------------------------
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 25, Issue 23
*****************************************
