On 06/02/06, John Hughes [EMAIL PROTECTED] wrote:
Cale Gibbard wrote:
That said, I'd *really* like to see monad comprehensions come back,
since they align better with the view that monads are container types,
dual to the view that monads are computations, which is supported by
the do-syntax.
Hello John,
Monday, February 06, 2006, 10:39:59 AM, you wrote:
That said, I'd *really* like to see monad comprehensions come back,
JH We did consider more aggressive defaulting to address the ambiguity
JH problems with monad comprehensions--defaulting Monad to lists, for
JH example, or
On Sun, 5 Feb 2006, Lennart Augustsson wrote:
I don't use lists very much. They are not the right data structure
for many things.
Certainly, but lists are useful as interim data structure or for
initialising complex data structures.
So : is not as common as :: in my code. I checked a small
John Peterson wrote:
I think the point was that all syntax (like list comprehensions or
pattern matching) in Haskell is tied directly to the Prelude. So [ f
x ...] is ALWAYS using the Prelude definitions of things while map
could be hidden and redefined.
Yes, of course. I was implicitly
Hello Henning,
Monday, February 06, 2006, 4:12:44 PM, you wrote:
In my opinion all the special syntactic sugar for lists should go
away. I don't think lists are special enough to motivate it.
HT Fine, someone shares my attitude towards the list sugar. Nevertheless, do
HT you mean with 'no
On Feb 6, 2006, at 9:19 AM, Bulat Ziganshin wrote:
Hello Ketil,
Monday, February 06, 2006, 4:06:35 PM, you wrote:
foo :: !Int - !Int
KM (Is the second ! actually meaningful?)
yes! it means that the function is strict in its result - i.e.
can't return
undefined value when strict
Bulat Ziganshin wrote:
Hello Ketil,
KM (Is the second ! actually meaningful?)
yes! it means that the function is strict in its result - i.e. can't return
undefined value when strict arguments are given.
Unfortunately this interpretation runs pretty quickly into theoretical
difficulties. A !
Ben Rudiak-Gould wrote:
As Robert Dockins said, it's not implemented, and it isn't clear how
to implement it. At this point it's looking fairly likely that my PhD
thesis will be on this very topic, so stay tuned.
Isn't all this already implemented in Clean?
Regards, Brian.
Hello Peter,
Monday, February 06, 2006, 10:24:01 PM, you wrote:
moving to nescafe :)
PS You can find further information about the library at the
PS page http://haskell.org/haskellwiki/Library/Streams and
PS download it as http://freearc.narod.ru/Streams.tar.gz
PS Is there any chance of
Hello Robert,
Monday, February 06, 2006, 8:40:11 PM, you wrote:
foo :: !Int - !Int
btw, it's just implemented in the GHC HEAD
RD Actually, I think strict _patterns_ are implemented. You are talking
RD about strict _type annotations_, which is rather different.
yes, i was wrong
RD There
On Feb 6, 2006, at 19:33, Brian Hulley wrote:
Clean allows (AFAIK) several distinctions to be made:
1) ![a] means that the list of a's is a strict argument, just like
writing !b
2) [!a] means that the list is head strict (List1 a)
3) [a!] means that the list is tail strict (List2 a)
4)
On 2/6/06, John Hughes [EMAIL PROTECTED] wrote:
The trouble with monad comprehensions was that it became far too easy to
write ambiguous programs, even when you thought you were just working
with lists.
Would the Haskell98-style solution be to add defaulting for Monads?
--
Taral [EMAIL
Hi,
I would like to ask about what are tha main features
of functional programming?
Additionally, about FAD: A Functional Analysis and
Design Methodology
What kind of software can i develop with this
methodology?
thanks for your answers
Abigail.
I would like to ask about what are tha main features
of functional programming?
If you are new to functional programming, read this
http://haskell.org/haskellwiki/Introduction
What kind of software can i develop with this
methodology?
I'm not sure what you mean by your question as it is
On Mon, Feb 06, 2006 at 11:13:47PM +0300, Bulat Ziganshin wrote:
btw, i have the counter proposal - automatically convert IORefs of
simple types to the fast internal variables like the Int automatically
converted to the Int#. The same applies to automatic conversion of
arrays to the unboxed
On Mon, Feb 06, 2006 at 04:19:03PM -0800, John Meacham wrote:
On Mon, Feb 06, 2006 at 11:13:47PM +0300, Bulat Ziganshin wrote:
btw, i have the counter proposal - automatically convert IORefs of
simple types to the fast internal variables like the Int automatically
converted to the Int#. The
Hey Bulat,
I tried removing the import System.Win32, but unfortunately it
only got me so far:
| Examples$ ghc -i.. -O2 -funbox-strict-fields --make wc.hs -o wc
| Chasing modules from: wc.hs
| [ 1 of 16] Compiling System.FD( ../System/FD.hs, ../System/FD.o )
|
|
17 matches
Mail list logo
