[Added a subject. Please accept my apologies! Foundations of AOP and AO
languages have benefitted from the functional programming community for a while
now. Haskellers, please have a look. Thanks! Ralf]
Call For Papers
FOAL: Foundations of Aspect-Oriented Lang
[Foundations of AOP and AO languages have benefitted from the functional
programming community for a while now. Haskellers, please have a look. Thanks!
Ralf]
Call For Papers
FOAL: Foundations of Aspect-Oriented Languages 2007
A one day workshop affiliated wit
Arthur,
constrFields eventually returns some mangled strings from the abstract syntax
tree; see ghc-fptools/ghc/compiler/basicTypes/DataCon.lhs; and that abstract
syntax promises to be order-preserving.
It says (not surprisingly):
dcFields :: [FieldLabel],
-- Field labe
Dear Haskellers,
The following paper may still benefit from your comment.
The final version is only due per 10 August 2006.
Thanks,
Ralf Laemmel
--
http://homepages.cwi.nl/~ralf/gpce06/
Title: Software Extension and Integ
Bulat wrote:
> it seems that Haskell continues to be a source of new technologies for
> other languages. i will wait for GADT for C# :)
No need to wait:
http://doitest.acm.org/10.1145/1094811.1094814
" We show that existing object-oriented programming languages such as
Java and C# can express GAD
Bas,
There is a really easy (and intended) way to make this work.
See Sec. 6.4 SYB1 paper (TLDI 2003).
- You compose things as follows:
simplify = id `extT` simplifyRhs `extT` simplifyExp `extT` ...
- You apply everything right away to simplify.
There is no need to use a class in your case.
Ho
RULE'06, 7th International Workshop on Rule-Based Programming, 11th August,
2006, Seattle, USA, A Satellite Event of RTA
http://www.dcs.kcl.ac.uk/events/RULE06/
IMPORTANT DATES
- 14th May, 2006 Deadline for electronic submission of papers
- 15th June,
==
Call for Papers
RULE 2006
7th International Workshop on Rule-Based Programming
http://www.dcs.kcl.ac.uk/events/RULE06/
Seat
Two new papers available:
Book review
"The Haskell Road to Logic, Maths and Programming" by Kees Doets and Jan van
Eijck
To appear in JoLLI journal; 13 pages.
http://www.cs.vu.nl/~ralf/JoLLI06
Executive summary: The "Haskell road" is an excellent book worth
considering as course material and read
Dear Frank,
HList is definitely tested with 6.4. See transcript below. My guess
would be that you are perhaps not running with options as stated in the
Makefile. Anyway, if your problems persist, I am happy to take this
offline.
Merry Christmas,
Ralf
[EMAIL PROTECTED] ~/projects/HList/src
$ ghc
FOAL: Foundations of Aspect-Oriented Languages
--- CALL FOR PAPERS ---
Submission deadline: 25 January 2006
A one day workshop affiliated with AOSD 2006 in Bonn, Germany, on March 21,
2006.
Themes and Goals
FOAL is a forum for research in foundations of aspect-oriented programming
languages.
Good questions.
You can't have a polymorphic typecase like "`extQ` (show :: Show a => a
-> String )" because that's not really a *type*case. It is too
polymorphic.
You can have a polymorphic typecase like "`extQ` ( lshow :: [ a ] ->
String )" because that's covered by the SYB2 paper; you need ex
Hi,
'isBoxed (Carton func)' fails because there is no way whatsoever that any
expression context will disambiguate the x y type variables of func's type.
That is, the type of `isBoxed (Box func)` does not expose x (and y -- the
latter being irrelevant because of the fundep); so there is no way
Just for the record,
Cobol has a long history of specifying local rounding options.
More recently, the options for rounding are elaborated in the context of
adding standard arithmetic.
http://www.cobolportal.com/j4/files/05-0152.doc
Ralf
> -Original Message-
> From: [EMAIL PROTECTED] [ma
> Define a type A such that for any type B you can define
>
> up :: B -> A
> down :: A -> Maybe B
>
> such that
>
> down . up = Just
>
> You can do this quite easily in Java or C++, mutatis mutandis. You
can't
> do this in Haskell, I don't think. You can't actually do this in
>
I would rather argue that:
- Template Haskell approx. *compile-time* reflection
- Scrap your boilerplate II (ICFP 2004) approx. *run-time* reflection
- Generic Haskell is effectively a Haskell generator
Ralf
P.S.: Another way to get *compile-time* reflection in Haskell is of course
type-level prog
An extended technical report has been released at:
TR & software: http://homepages.cwi.nl/~ralf/OOHaskell/
TR: http://arxiv.org/abs/cs.PL/0509027
"Haskell's overlooked object system"
10 September 2005, 79 pages
by O. Kiselyov (FNMOC, Monterey, CA, USA)
and R. Laemmel (Microsoft Corp., WA, USA)
> If we were on an OOP mailing
> list, I could ask for days how to simulate pattern matching and
> algebraic types---and get a nonsensical runaround involving the
visitor
> pattern and huge swaths of unreadable code.
In such a case, I would be happy if someone told me that there is work
like this:
Lennart,
from a textbook perspective I agree
that this solution should be mentioned to make it easy
for non-Haskellers to get into the subject.
However (as you of course know, but I just don't understand
why you don't dare to mention the limitations a) and b) ...)
a)
Your constructor-based appr
Andreas Rossberg:
Andreas R. wrote:
> "dynamic binding" is just the OOO way of saying
> "calling a first-class function").
Let me presume that dynamic binding
was meant here in the sense of late binding, in the sense of
subtyping polymorphism. At least, the given shapes example
strongly suggest
Andrew,
you are circumventing the hard problem!
(Even though I am sure you just forgot to mention it.)
That is, the question is about drawing a *list* of shapes.
As correctly observed by Rathman ages back, one naturally
ends up with existential quantification when simulating
dynamic binding. Ex
Bulat,
Bulat wrote:
> just create list of draw functions itself:
>
> [drawCircle (10,10) 5, drawSquare (20,20) 10]
No! the exercise is about lists of shapes
not lists of results of drawing shapes.
This is clearly a major difference.
Bulat wrote:
> for more complex tasks - declare interface a
At the risk of being excluded from this list
(because of an unmoral number of plugs about OOHaskell),
here we go: http://homepages.cwi.nl/~ralf/OOHaskell/
You might start with the appendices of the paper and also read Section 2
which finally implements the Shapes example with ease. The C++ encodin
Please find attached the call for participation for the Summer School on
Generative and Transformational Techniques in Software Engineering
4 - 8 July, 2005, Braga, Portugal
http://www.di.uminho.pt/GTTSE2005
Registration is open.
There are 17 confirmed tutorials and other presentations.
--
Ralf
24 matches
Mail list logo
