the combined monadic action down to core language
you'll get some nested case-expressions, and I don't think that
a correct program transformation could destroy the order of them
(which would be necessary to put another IO action between the others).
David Sabel
---
JWGU Frankfurt
HasFuse Version 1.1
===
HasFuse is a modification of the Glasgow Haskell Compiler which has
built-in some precautions for the execution of unsafePerformIO, hence
the name HasFuse. This means the user does not have to undertake
Inling isn't the only optimization, which can lead to a wrong behavior,
let floating out and common subexpression elimination can also
change the behavior
of programs using unsafePerformIO.
Our research group has developed the calculus FUNDIO as a semantic basis:
It's a non-deterministic
Schupke wrote:
I hope this is not a stupid idea - but why not contribute the changes
as patches back to the main GHC development?
Keean.
David Sabel wrote:
Inling isn't the only optimization, which can lead to a wrong
behavior,
let floating out and common subexpression elimination can also
Keean Schupke wrote:
David Sabel wrote:
The main reason is: Nobody asks for it.
Actually I think Simon Marlow has talked in the past about wanting
to make GHC only do safe optimisations on unsafePerformIO.
I conjecture, a problem is:
if you use FUNDIO as a semantics for Haskell, you have to give
Dear Janis,
thanks for your great work in preparing the report.
David
Am 17.11.2012 22:03, schrieb Janis Voigtländer:
On behalf of all the contributors, I am pleased to announce that the
Haskell Communities and Activities Report
(23rd edition, November 2012)
is
(University of Minnesota, Morris)
Joachim Niehren(INRIA Lille)
David Sabel(Goethe-University Frankfurt am Main)
Masahiko Sakai (Nagoya University)
Manfred Schmidt-Schauß (Goethe-University Frankfurt am Main) - chair
Eijiro Sumii (Tohoku University)
Janis
* David Sabel
Structural Rewriting in the Pi-Calculus
* Guillaume Madelaine, Cedric Lhoussaine and Joachim Niehren
Attractor Equivalence: An Observational Semantics for Reaction Networks
* Naoki Nishida, Makishi Yanagisawa and Karl Gmeiner
On Proving Soundness of the Computationally
I wonder why the downloads section doesn't link to the Haskell platform.
What's the reason for it?
David
Am 15.02.2015 um 08:50 schrieb Gershom B:
I’m pleased to announce that http://www.haskell.org has received its first
significant design update since 2010! More significantly, for the first
-Schauss (Goethe-University Frankfurt am Main)
David Sabel (Goethe-University Frankfurt am Main)
Masahiko Sakai (Nagoya University)
Janis Voigtlaender (University of Bonn)
Johannes Waldmann (HTWK Leipzig)
Harald Zankl(University of Innsbruck)
Organizers
Towards Modelling Actor-Based Concurrency in Term Rewriting
* David Sabel and Manfred Schmidt-Schauss
Observing Success in the Pi-Calculus
* Koichi Sato, Kentaro Kikuchi, Takahito Aoto and Yoshihito Toyama
Context-Moving Transformation for Term Rewriting Systems
* Sjaak Smetsers, Ken
University)
David Sabel (Goethe-University Frankfurt am Main) -- chair
Masahiko Sakai (Graduate School of Infomation Science, Nagoya University)
Manfred Schmidt-Schauss (Goethe-University Frankfurt am Main)
Janis Voigtländer (University of Nijmegen)
Johannes Waldmann (HTWK Leipzig)
Fer-Jan de Vries
(Nagoya University)
David Sabel (Goethe-University Frankfurt am Main) -- chair
Masahiko Sakai (Graduate School of Infomation Science, Nagoya University)
Manfred Schmidt-Schauss (Goethe-University Frankfurt am Main)
Janis Voigtländer (University of Nijmegen)
Johannes Waldmann (HTWK Leipzig)
Fer-Jan de
València)
Maribel Fernandez (KCL)
Delia Kesner (Université Paris-Diderot)
Sergueï Lenglet (Université de Lorraine)
Elena Machkasova (University of Minnesota, Morris)
William Mansky (Princeton University)
Joachim Niehren (INRIA Lille)
Naoki Nishida (Nagoya University)
David Sabel (Goethe-University
Committee
David Sabel (General Chair), Computer Science Institute
Goethe-University Frankfurt am Main, Germany
___
Haskell mailing list
Haskell@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell
Organizing Committee (Goethe-University Frankfurt am Main, Germany)
Ehud Cseresnyes
Nils Dallmeyer
Bircan Dölek
Ronja Düffel
Lars Huth
Leonard Priester
David Sabel (General Chair)
___
Haskell mailing list
Haskell@haskell.org
http
)
- Chung-Chieh Shan, University of Indiana.
Calculating Distributions
Accepted Papers
===
- Maciej Bendkowski and Pierre Lescanne.
Combinatorics of explicit substitutions
- Manfred Schmidt-Schauss, David Sabel and Nils Dallmeyer.
Sequential and Parallel Improvements
==
PPDP 2018: First Call for Papers
==
20th International Symposium on
Principles and Practice of Declarative Programming
(Apologies if you receive multiple copies of this CFP. Please circulate.)
==
PPDP 2018: Second Call for Papers
==
20th International
News: The submission deadline is extended until Monday, May 8, 23:59 AoE!
==
PPDP 2018: Deadline Extension
==
20th
at 08:14:30PM +0200, David Sabel wrote:
Hi!
Subject: foldr f (head xs) xs is not the same as foldr1 f xs
I think you forgot about tail:
foldr f (head xs) (tail xs)
Best regards
Tomasz
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users
Hi,
I think it's the let floating (out) together with common subexpression
elimination:
ghc --make -O2 -no-recomp -fno-cse -o curry-no-cse curry.hs
[1 of 1] Compiling Main ( curry.hs, curry.o )
Linking curry-no-cse ...
ghc --make -O2 -no-recomp -fno-full-laziness -o
Hi Bernd,
Bernd Brassel wrote:
Hi David,
thank you! This is really useful information!
I think it's the let floating (out) together with common subexpression
elimination:
ghc --make -O2 -no-recomp -fno-cse -o curry-no-cse curry.hs
[1 of 1] Compiling Main ( curry.hs,
In read your paper Tackling the Awkward Squad: monadic input / output,
concurrency, exceptions, and foreign-language calls in Haskell, and have
a question about unsafePerformIO.
In your operational semantic of the IO-Monad you tell nothing about, how
'unsafe' IO actions are performed, is there
I'm, analysing the IO-system of the GHC and need more
information about
it.
More precisely: How switches the run-time-system between (normal)
evaluation and performing of IO-actions?
I read the rts-paper, but didn't find any information about this.
Can somebody give a short
Hi,
can somebody explain what the notation (# ... #)
means?
For example it is used in the definition of unsafePerformIO:
unsafePerformIO :: IO a - a
unsafePerformIO (IO m) = case m realWorld# of (# _, r #) - r
Thanks, David
___
- Original Message -
From: Simon Marlow [EMAIL PROTECTED]
Sent: Tuesday, September 24, 2002 2:58 PM
Subject: RE: unsafePerformIO
[...]
As for sharing, we currently don't provide any guarnatees, although we
should. It is currently the case that if you write
a = unsafePerformIO
While installing the file the following error
occurs:
Invalid Drive c:\
after that error message the "GHC setup ended
prematurely because of an error"
MyComputer doesn't have a drive c:\, the
windows partition is on d:\.
The previous .msi-Version (5.04) didn't have this
error.
David
The error occurs before I have this choice.
Hi there,
the installer gives you a choice between Typical, Custom,
and Complete -- choose the Custom option to pick an
installation location other than the default.
hth
--sigbjorn
- Original Message -
From: David Sabel
this transformation?
David Sabel
___
Glasgow-haskell-users mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
Of course, I used unsafePerformIO in an unsafe way!
I'm thinking about a way to make unsafePerformIO safe.
Therefore the compiler can't do any transformation the ghc does and I want
to locate these transformations.
- Original Message -
From: Simon Marlow [EMAIL PROTECTED]
To: David Sabel
- Original Message -
From: Albert Lai [EMAIL PROTECTED]
To: [EMAIL PROTECTED]
Sent: Wednesday, October 30, 2002 7:35 AM
Subject: Re: Optimisation and unsafePerformIO
David Sabel [EMAIL PROTECTED] writes:
{-# NOINLINE b #-}
b x = if even x then unsafePerformIO getChar else
Hallo,
my question ist, how the seq operator is translated into the
GHC-core-language?
I had suspected, the core-language has a special strictness-operator, but I
saw, that this is not the case.
David Sabel
JWGU Frankfurt
___
Glasgow-haskell-users
-
| From: David Sabel [mailto:[EMAIL PROTECTED]]
| Sent: 03 January 2003 14:11
| To: [EMAIL PROTECTED]
| Subject: Translating seq into Core
|
| Hallo,
|
| my question ist, how the seq operator is translated into the
| GHC-core-language?
|
| I had suspected, the core-language has a special
set of
constants,
or include the literals also integers, which can be infinite? If that is the
case,
how are the (unboxed) integers represented in the ghc-core-language?
Thanks for your comments!
David Sabel
-
JWGU Frankfurt
___
Glasgow
it off for now
and
later modify the implementation for this transformation.
David Sabel
---
JWGU Frankfurt
___
Glasgow-haskell-users mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users
Hi,
Can someone tell me, where exactly (in the code of ghc5.04.3)
the case-eta-expansion is performed, I searched
the modules of the simplifier, but didn't find this transformation.
Or is it no longer performed in ghc5.04.3?
Thanks,
David
___
- Original Message -
From: Simon Peyton-Jones [EMAIL PROTECTED]
To: David Sabel [EMAIL PROTECTED];
[EMAIL PROTECTED]
Sent: Monday, July 21, 2003 9:53 AM
Subject: RE: case-eta-expansion
Not quite sure what you mean by case eta expansion.
I mean this transformation:
case e of {p1 - e1
Hi,
the case-identity transformation is
case e of
pat1 - pat1 === e
...
patn - patn
It's performed in SimplUtils.mkCase1.
My (very special) question is: How do you ensure, that
there's a case-alternative for every constructor of the type of e?
Otherwise you could transform
case
In Core, the list of alternatives is always exhaustive.
Ok, thanks.
So I assume the dead alternative elimination is no longer done in
the simplifier?
(
The dead alternative elimination is defined as:
case x of=== case x of
P1 - E1 P1 - E1
...
Hi,
the following toy program has a strange behaviour,
when compiling with ghc5.04.3 an no optimisation (-O0)
module Main(main) where
import System.IO.Unsafe
main = case unsafePerformIO (print test) of
() - main
ok, probably I use unsafePerformIO in an unsafe way and so on,
to do with the STG-Code generation or
with normal code generation, and it depends on the fact, if
the function is exported or not.
Any hints in this direction???
Thanks,
David
- Original Message -
From: Simon Marlow [EMAIL PROTECTED]
To: David Sabel [EMAIL PROTECTED]; Jon Fairbairn
[EMAIL
On 2003-08-11 at 11:44+0200 David Sabel wrote:
module Main(main) where
import System.IO.Unsafe
main = case unsafePerformIO (print test) of
() - main
ok, probably I use unsafePerformIO in an unsafe way and so on,
but executing the program prints infinitely often test
Hi,
you can turn off let-floating by compiling without optimizations,
i.e. without using a -O flag or using -O0 explicitly.
The disadvantage is that most of all other optimizations
are turned off too.
Another possibility would be to compile your program with HasFuse
Hi,
Results:
method runtime (s)
---
pure0.7
ffi 3.2
fastMut 15
ioref 23
I very strongly suspect that it is the unsafePerformIO that hurts
performance in the fastMut case. Otherwise
Hi,
you can make every function being an instance of class Show,
this works for me:
instance Show (a - b) where
show _ = FUNCTION
data Element = Int Int | Float Float | Func (Machine - Machine)
deriving Show
David
Johan Grönqvist wrote:
I am a haskell-beginner and I wish to write a
Malcolm Wallace wrote:
Matthias Fischmann [EMAIL PROTECTED] wrote:
No, your Fin type can also hold infinite values.
let q = FinCons 3 q in case q of FinCons i _ - i == _|_
does that contradict, or did i just not understand what you are
saying?
That may be the result in
Hi,
when checking the first monad law (left unit) for the IO-monad (and also
for the ST monad):
return a = f ≡ f a
I figured out that there is the distinguishing context (seq [] True)
which falsifies the law
for a and f defined below
let a = True
let f = \x - (undefined::IO Bool)
seq
Sicard-Ramírez schrieb:
On 2 March 2010 15:44, Luke Palmer lrpal...@gmail.com
mailto:lrpal...@gmail.com wrote:
On Tue, Mar 2, 2010 at 1:17 PM, David Sabel
sa...@ki.informatik.uni-frankfurt.de
mailto:sa...@ki.informatik.uni-frankfurt.de wrote:
Hi,
when checking the first
As a starting point I would suggest
Peter Sestoft : Deriving a lazy abstract machine, Journal of Functional
Programming 7(3), 1997
( http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.50.4314 )
Different abstract machines for call-by-need evaluation are built
starting from Launchburys
Hi,
the definition in the book is a syntactic one, you are not allowed to
beta-reduce when applying the definition.
In particular
E = E1 E2 = (\x.xy)(\z.z)
The definition speaks about the term
(\x.xy)(\z.z) and not about (\z.z)y
and the definition does not speak about occurences of
Hi,
Maybe Hat - The Haskell Tracer can help:
http://haskell.org/hat/
- Original Message -
From: [EMAIL PROTECTED]
To: [EMAIL PROTECTED]
Sent: Sunday, October 19, 2003 10:25 AM
Subject: tracing Haskell programs
Hi folk
Is there a way to follow the execution of a Haskell program?
Hi!
I'm also interested, how to get this example working:
http://www.haskell.org/pipermail/haskell/2001-November/008336.html
This seems to be an old discussion:
http://www.haskell.org/pipermail/libraries/2001-April/000358.html
Was a strictReadFile implemented in the meantime?
Here's my
A perhaps acceptable notion of the property we want (purity etc.) is
that all the extensions of the purely functional core language of Haskell
(say the lazy lambda calculus extended with data constructors, etc) are
_conservative_, that is all the equations that hold
in the pure core language
Am 13.04.2013 00:37, schrieb Timon Gehr:
On 04/12/2013 10:24 AM, o...@okmij.org wrote:
Timon Gehr wrote:
I am not sure that the two statements are equivalent. Above you say
that
the context distinguishes x == y from y == x and below you say that it
distinguishes them in one possible run.
Am 18.04.2013 15:17, schrieb Duncan Coutts:
On Mon, 2013-04-15 at 20:44 +0200, David Sabel wrote:
A very interesting discussion, I may add my 2 cents:
making unsafeInterleaveIO nondeterministic indeed seems to make it safe,
more or less this was proved in our paper:
http
56 matches
Mail list logo
