(Chapman U., USA; PC co-chair)
Wolfram Kahl (McMaster U., Canada; PC co-chair)
Tadeusz Litak(Erlangen, Germany)
Larissa Meinicke (U. Queensland, Australia)
Szabolcs Mikulas (London, UK)
Bernhard Möller (Augsburg, Germany
> I have a file with 100 lists, with 100 ints.
>
> I have to read the file and apply the map and sort functions on lists.
>
> II did it to read file:
>
> learquivo :: FilePath -> IO ([[Int]])
> learquivo s = do
> conteudo <- readFile s
> return (read conteudo)
>
Norman,
>
> > AFAIK, the normal understanding is that recursive types
> > are the least fixed points of endofunctors on the category of CPOs,
> > and it is the CPO property that least upper bounds of chains exist
> > that forces the existence of infinite lists.
>
> But ML has CPOs and
Norman,
> Haskell permits recursive definitions at both the type level and the
> term level. Here's an example definition at the type level:
>
> data Intlist = Nil | Cons Integer Intlist
>
> If my understanding is correct, Haskell takes as the definition of
> `Intlist` the *greatest* s
>
> Graphics.Rendering.OpenGL.GL.CoordTrans is awfully long.
>
> I think that "Graphics.Rendering." is clutter, and "OpenGL.GL." seems
> redundant to me. I'd very much like to encourage the idea that tremendously
> long package names ought to be considered poor form.
... or be made abstrac
>
> A good one indeed, Simon.
Check the ``Received: from'' headers of the original message...
Wolfram
___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell
Niklas Broberg" released a new version of
haskell-src-exts --- Thank you Niklas! --- and listed as one of the
``missing features'':
>
> - Support for (un-parenthesised) higher-ranked types as arguments.
> haskell-src-exts supports e.g. foo :: b -> (forall a . [a]) -> b
> but not foo :: b ->
"S. Alexander Jacobson" <[EMAIL PROTECTED]> wrote:
> The correct answer, I believe, is to require that module authors put
> flags in the module themselves where they belong. At very least it
> should be considred bad style not to have them in your code and really
> what would make more sen
whether you look in the Haskell report,
or for a definition of the ``functional rewriting strategy''
in the theoretical literature.
To fix exactly this problem was my original goal
when I started developing a family of Pattern Matching Calculi,
see http://www.cas.mcmaster.ca/~kahl/PMC/
>
> It's just annoying that turning a partial function into a total one
> looses so much strictness, since it prevents strictness propagation. Of
> course, this is easily solved using a `strict' Maybe:
> data Perhaps a = Just' !a | Nothing'
>
> Are other people experiencing the same thin
>
> Does anyone have a nice way to format the "~" of a lazy pattern in
> lhs2TeX? I use
>
> %format ~ = "{} ^\sim "
>
> but the result isn't as pretty as I'd like. For one thing, no space
> is inserted before the "~" after a lambda, "do", or whatever.
``Nice'' is in the eye of the b
Louis-Julien Guillemette <[EMAIL PROTECTED]> wrote:
> Say we are using a GADT to represent a simple language of boolean
> constants and conditionals,
>
> data Term a where
>B:: Bool -> Term Bool
>Cnd :: Term Bool -> Term t -> Term t -> Term t
>
> and we would like to perfo
"Simon Peyton-Jones" <[EMAIL PROTECTED]> writes:
> Can anyone remember when the Haskell mailing list first opened? Does
> anyone have an archive that goes right back to the beginning?
In my news archives
(which start 9 Feb 92,
shortly after we got an internet connection back there :-)
I found
Hi all,
somebody wrote something which reminds me:
* *
* The ``next stable version'' of the Haskell language definition *
* should be cal
Shin-Cheng Mu <[EMAIL PROTECTED]> wrote:
>
> Occasionally I would need to define recursive datatypes
> using an explicit fixed-point operator, such as:
>
> > data Fix f = In (f (Fix f)) deriving (Show, Eq)
> > data L a x = Nil | Cons a x deriving (Show, Eq)
>
> However, Haske
ht 3 : h
and ctx3 therefore matches to
\ f -> (1, f [Left 4, Right 5])
Have fun!
Wolfram
-
@InProceedings{Tullsen-2000,
author = {Mark Tullsen},
title = {First Class Patterns},
crossref = {PADL2000},
pages = {1--15},
URL = {
Tomasz Zielonka <[EMAIL PROTECTED]>
proposed an interesting kind of ``second-order as-patterns''
that are ``safe'' from the usual problems of second-order matching
by virtue of fixing (at least) the spine
of the images of the second-order variables.
Tomasz' first example (incorporating Stefan Hold
Gavin Lowe <[EMAIL PROTECTED]> asked for:
>
> - a graphical representation of dependencies between modules.
HsDep available from
http://www.cas.mcmaster.ca/~kahl/Haskell/
uses dot from AT&T's graphviz suite.
You can of course tune with the generated dot file manually
t some first
results over the summer.
It will probably connected into RATH (Relation Algebra Tools for Haskell),
old homepage waiting to be transferred and updated:
http://ist.unibw-muenchen.de/relmics/tools/RATH/
Wolfram
---
Dr. Wolfram Kahl
Associate
John Hughes wrote:
> What we need is different binding syntax for monomorphic and polymorphic
> bindings. Roll on := and = ...
If I recall correctly, in some earlier language (KRC?)
this difference was achieved by letting let-bindings be
polymorphic, and where-bindings be monomorphic.
The ide
Marcin 'Qrczak' Kowalczyk <[EMAIL PROTECTED]> asks:
>
> 12 Sep 2001 12:37:25 -, [EMAIL PROTECTED]
><[EMAIL PROTECTED]> pisze:
>
> > * Currently HOPS implements only one evaluation strategy,
> > namely leftmost outermost graph rewriting with sharing preservation
> > (without automatic s
Olaf Chitil <[EMAIL PROTECTED]> summarised the 10 minute talks
of this years Haskell workshop, including my presentation:
> Wolfram Kahl: Animating Haskell by Term Graph Rewriting
> HOPS is a system for term graph rewriting that can also show the
> rewriting steps in a grap
Simon Peyton-Jones <[EMAIL PROTECTED]> wrote:
> If, however, you can suggest some specific sentences that would help
> to eliminate confusion, then please do suggest them.
It is, to a certain extent, a design decision.
One possibility might be to change
> Types are related by a generalizatio
The Haskell 98 report (also in the current revised version)
includes the following in section 4.1.4:
> Types are related by a generalization order (specified below);
> the most general type that can be assigned to a particular expression
> (in a given environment) is called its principal type
Simon Peyton-Jones wrote:
> I've finished what I hope is the final version of the Haskell 98
> Language and Library Reports
> http://research.microsoft.com/~simonpj/haskell98-revised
haskell98-library-html/index.html still contains the following line:
The Haskell Library Report 1.4
B
Jeffrey R. Lewis <[EMAIL PROTECTED]> argued that
the monomorphism restriction enabled translations of
let-bindungs into lambda-bindings:
> > let z = x + ?y in z+z
> >
>
> [...]
>
> The example above becomes:
> (\z -> z + z) (x + ?y)
In Hindley-Milner type systems,
the poin
As a minor point in our draft paper
``From Type Classes to Module Constraints''
http://ist.unibw-muenchen.de/Haskell/ModConstraints/
we argue that implicit parameters and conventional type class contexts
are really the same thing.
This immediately dictated the answers to the first two questi
style!
Programme Committee
===
Rudolf Berghammer (Kiel), Jules Desharnais (Quebec), Wolfram Kahl (Munich),
David L. Parnas (Hamilton), Gunther Schmidt (Munich)
-
E-Mail: [EMAIL PROTECTED]
Workshop home page: URL: http://ist.unibw-muenchen.de/RelMiS
technical report, all available from the EdComb home page at URL:
http://ist.unibw-muenchen.de/EdComb/
Best regards,
Wolfram Kahl
Simon Marlow writes:
> You didn't mention the accumulating parameter version:
[[[with correction pointed out by Koen Claessen:]]]
> lines :: String -> [String]
> lines s = lines' s ""
> where
> lines' [] acc = [reverse acc]
> lines' ('\n':s) acc = reverse acc : lines' s ""
> li
Shin-Cheng Mu <[EMAIL PROTECTED]>
is puzzled why the derived foldr version of lines
is significantly faster than the prelude version,
which he recognises as an unfold:
> I am curious why the Prelude version is less efficient than the
> your fold version? It seems to me the fold version constr
>| Char.isSpace y = words1 ys
>| otherwise = [] : case words ys of
>[] -> [[y]]
>(zs:zss) -> (y:zs):zss
All the details can be found at:
http://ist.unibw-muenchen.de/Lectures/FT2000/FP/Lines.html
Best regards,
Wolfram Kahl
On glasgow-haskell-users, Simon Peyton-Jones <[EMAIL PROTECTED]>
answered my question arising from a different thread:
>
> | This is something that I have long been wondering about
> | (perhaps it is just because of my ignorance):
> | Wouldn't stable pointers be a cheaper and more appropriate
uddled up,
I point to a page where I conserve an old USENET NEWS posting
by Tom DeBoni <[EMAIL PROTECTED]> quoting the definitions
from a few relevant books:
http://www2.informatik.unibw-muenchen.de/kahl/reftrans.html
Regards,
Wolfram
J.P. Morrison <[EMAIL PROTECTED]> writes on the dataflow list:
>
> I have been in the IT business for about 40 years, and have been
> maintaining PL/I programs intensively for the last year or so. In 1994
> I wrote a book called "Flow Based Programming" which was quite well
> recei
Simon Peyton-Jones <[EMAIL PROTECTED]> writes:
>
> > In other words, it is a bug (and GHC and Hugs don't do it
> > right - see my previous message; from your comment, I
> > presume HBC also doesn't follow the definition). I think,
> > the only Right Thing is to remove this awful rule (unles
Andreas C. Doering <[EMAIL PROTECTED]> writes:
>
> I would like to have a comparison instruction that compares the internal
> reference of two objects.
> Let's call it "req".
>
> req :: a -> a -> Bool
>
> -- of course it is an equivalence operation
> req x x = True
> req x y = req
Hi all,
since I have gotten into the habit to relate proposed diagonalisation
function, I will not resist this time, either ;-)
Koen Claessen <[EMAIL PROTECTED]> writes:
>
> as // bs = diag [] [ [ (a,b) | a <- as] | b <- bs ]
>
> diag current [] = diag [] current
> di
Nguyen Phan Dung <[EMAIL PROTECTED]> writes:
>
> If I have the following declaration:
>
> class Soup where
> ...
>
> instance Soup String where
> ...
>
> instance Soup t => Soup [t] where
> ...
>
> This will lead to an error: "instance overlapping".
>
> Is there anyway to solv
Hi,
you write (message from Tom Pledger on Thu, 15 Jul 1999 13:33:06 +1200 (NZT))
(and I hope you do not mind that I send this response to the list, too):
>
> Someone was saying that my diag function ran out of space, but I've
> lost track of the message. Was it yours?
>
Yes, it was mine.
Jón Fairbairn <[EMAIL PROTECTED]> writes:
>
> > diagonalise:: [[a]] -> [a]
> > diagonalise l = d [] l
>
>
> > d [] [] = []
> > d acc [] = -- d [] acc would do, but muddles the order;
> >heads acc ++ d (rests acc) []
> > d ls (l1:rest) = heads (ls') ++ d (rests ls') rest
Jon Fairbairn ([EMAIL PROTECTED]) writes:
> On 11 Jul, Wolfram Kahl wrote:
> > [...]
> > The core function here is
> >
> > > (diagonalize (1 :: Integer)) :: [[a]] -> [a]
> >
> > This function diagonalises finite or infinite lists
> &g
Stefan Kahrs <[EMAIL PROTECTED]> writes:
> I liked Mark's version, but let me add a related challenge.
>
> I defined a translation of //-list comprehensions
> that is analogous to the foldr-translation of list comprehensions
> (which optimises the map-concat approach) but works in the infin
In the meantime I have discovered a flaw in my original
diagonalisation in that it looped in finite cases.
This can easily be mended:
DiagWK1:
> diag :: [[a]] -> [a]
> diag = f id where
> f :: ([[a]] -> [[a]]) -> [[a]] -> [a]
> f a [] = split id (a []) []
> f a (l:ls) = split id (a [l]) ls
Mark P Jones <[EMAIL PROTECTED]> writes:
>
> Here's my definition of an integer free diagonalization function.
> [..] As written, I think
> it is a nice example of programming with higher-order functions,
> and, in particular, using function composition to construct a
> pipelined program:
Koen Claessen <[EMAIL PROTECTED]>
proposes the following diagonalisation function:
>
> [ (a,b) | (a,b) <- [1..] // [1..] ]
>
> For a suitable definition of (//), for example:
>
> (//) :: [a] -> [b] -> [(a,b)]
> xs // ys = diagonalize 1 [[(x,y) | x <- xs] | y <- ys]
>where
>
system HOPS
(
URL: http://www2.informatik.unibw-muenchen.de/kahl/HOPS/
)
which can also be considered as a fledgling theorem prover ---
anyway I expect the problems to be essentially the same.
I am trying to finish a short summary next week...
Wolfram
With respect to the new RULES mechanism presented by
Simon Peyton Jones (Thu, 22 Apr 1999),
Carsten Schultz <[EMAIL PROTECTED]> writes
> [...]
> > And what about algebraic simplification? Say,
> The same applies to our beloved monads.
> The compiler could be told about the monad laws.
Somebo
John Launchbury posed a nice puzzle about
mutual recursive bindings in the do notation:
test :: [Int]
test = do (x,z) <- [(y,1),(2*y,2), (3*y,3)]
Just y <- map isEven [z .. 2*z]
return (x+y)
isEven x = if even x then Just x else Nothing
---
Simon Peyton-Jones proposes:
> A Haskell 98 addendum
[ ... ]
> Well, the bits are frozen, but I propose to regard this as a gross
> "typo" and add it to the typos page.
[ ... ]
> So the "typo" fix I propose is
[ ... ]
> Any objections?
Call it Haskell 1.6 ;-)
Best,
W
Jeffrey R. Lewis" <[EMAIL PROTECTED]> wrote:
>
> Anyway, the only thing missing now in the above proposal
> is a similar flexibility with contexts.
> Say, you want `b' to be a bound, and thus use :<=,
> but you want the context to be exact
> (i.e. you don't want extra context elements to be
Starting from Jeffrey R. Lewis' <[EMAIL PROTECTED]> wish to
let partial type declarations express binding of SOME type variables
> > foo :: C a => a -> _b
and modulating the syntax proposed by Claus Reinke <[EMAIL PROTECTED]>,
> > foo :<= C a => a -> b
I suggested the following notat
To my last message:
> Jeffrey R. Lewis" <[EMAIL PROTECTED]> writes:
> >
> > foo :<= C a => a -> b roughly equiv to foo :: C _a => _a -> _b
> >
> > I can easily imagine that you might want some variables to be a bound, and
> > others to be exact, as in
> >
> > foo
Jeffrey R. Lewis" <[EMAIL PROTECTED]> writes:
>
> foo :<= C a => a -> b roughly equiv to foo :: C _a => _a -> _b
>
> I can easily imagine that you might want some variables to be a bound, and
> others to be exact, as in
>
> foo :: C a => a -> _b
>
> I don't think the
On Tue, 8 Sep 1998, Stephen H. Price <[EMAIL PROTECTED]> wrote:
On Mon, 7 Sep 1998, Simon Peyton-Jones wrote:
>
> * Incidentally, I'm leaning towards 'Haskell 98' as the name.
>
A couple of minor points:
a) Haskell 1998 would be more appropriate in the light of Year 2000
d of approach is big part of the motivation behind my
graphically interactive strongly typed term graph program development
and transformation system HOPS (work in progress), see
URL: http://diogenes.informatik.unibw-muenchen.de:8080/kahl/HOPS/
HOPS in principle is a language-independent term graph
, perhaps in terms of proof
> theory?
For typed term graphs, I am providing a declarative typing system
without any notion of type inference in (BibTeX below):
http://diogenes.informatik.unibw-muenchen.de:8080/
kahl/PAPERS/Kahl-1997d_UFDeclTy_colour.ps.gz -- For colour
57 matches
Mail list logo
