from:"Pieter Koopman"

[clean-list] IFL23 - Deadline extension - Symposium on Implementation and Application of Functional Languages

2023-07-31 Thread Pieter Koopman via clean-list

Dear all,

on special request, the deadline for draft paper submissions is extended
until *August 7th*, 2023.

*Scope*

The goal of the IFL symposia is to bring together researchers actively
engaged in the implementation and application of functional and
function-based programming languages. IFL 2022 will be a venue for
researchers to present and discuss new ideas and concepts, work in
progress, and publication-ripe results related to the implementation
and application of functional languages and function-based
programming.

Topics of interest to IFL include, but are not limited to:

* language concepts
* type systems, type checking, type inferencing
* compilation techniques
* staged compilation
* run-time function specialization
* run-time code generation
* partial evaluation
* abstract interpretation
* metaprogramming
* generic programming
* automatic program generation
* array processing
* concurrent/parallel programming
* concurrent/parallel program execution
* embedded systems
* web applications
* embedded domain specific languages
* security
* novel memory management techniques
* run-time profiling performance measurements
* debugging and tracing
* virtual/abstract machine architectures
* validation, verification of functional programs
* tools and programming techniques
* industrial applications
*Submissions and peer-review*

Following IFL tradition, IFL 2023 will use a post-symposium review
process to produce the formal proceedings.

Before the symposium authors submit draft papers. These draft papers
will be screened by the program chair to make sure that they are
within the scope of IFL. The draft papers will be made available to
all participants at the symposium. Each draft paper is presented by
one of the authors at the symposium. Notice that it is a requirement
that accepted draft papers are presented physically at the symposium.

After the symposium, a formal review process will take place,
conducted by the program committee. Reviewing is single blind. There
will be at least 3 reviews per paper. The reviewers have 6 weeks to
write their reviews. For the camera-ready version the authors can make
minor revisions which are accepted without further reviewing.

Contributions submitted for the draft paper deadline must be between
two and twelve pages long. For submission details, please consult the
IFL 2023 website at
https://urldefense.com/v3/__https://ifl23.github.io/__;!!HJOPV4FYYWzcc1jazlU!6fMCUPhH9HJMnp--zyBzSF58b1XygzW5n1cbN0tZa6qCECqpfmnLA4ObZ-IbraTk5OevpCQZbtn_jBMsFItSSiPma2vabUM$

.
*Where*

IFL 2023 will be held physically in Braga, Portugal, arranged by
University of Minho.

See the IFL 2023 website at
https://urldefense.com/v3/__https://ifl23.github.io/__;!!HJOPV4FYYWzcc1jazlU!6fMCUPhH9HJMnp--zyBzSF58b1XygzW5n1cbN0tZa6qCECqpfmnLA4ObZ-IbraTk5OevpCQZbtn_jBMsFItSSiPma2vabUM$

for more
information.

[image: beacon]
___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL23 first CFP

2023-04-03 Thread Pieter Koopman via clean-list

*Call for papers*

The 35th Symposium on Implementation and Application of Functional
Languages (IFL 2023)

Braga, Portugal, August 29th-August 31st, 2023
*Important dates*

Draft paper submission: July 31st, 2023
Draft paper notification:August 1st, 2023
Early registration deadline: August 11th, 2023
Late registration deadline: August 23rd, 2023
Symposium: August 29th - August 31st (3 days)
*Scope*

Topics of interest to IFL include, but are not limited to:

Contributions submitted for the draft paper deadline must be between
two and twelve pages long. For submission details, please consult the
IFL 2023 website at
https://urldefense.com/v3/__https://ifl23.github.io/__;!!HJOPV4FYYWzcc1jazlU!7jDg7CLKJsozIegnNZmSCeSvAJfmZK_EcGIETGk2SqKouu_rs1UwmB0m8UQHgVzSVbIlGCT0OMpOYJJLQXPcaZjYf-2-QZk$

.
*Where
*
IFL 2023 will be held physically in Braga, Portugal, arranged by
University of Minho.

See the IFL 2023 website at
https://urldefense.com/v3/__https://ifl23.github.io/__;!!HJOPV4FYYWzcc1jazlU!7jDg7CLKJsozIegnNZmSCeSvAJfmZK_EcGIETGk2SqKouu_rs1UwmB0m8UQHgVzSVbIlGCT0OMpOYJJLQXPcaZjYf-2-QZk$

for more
information.

[image: beacon]
___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL22: Early registration deadline August 15th

2022-08-15 Thread Pieter Koopman via clean-list

*IFL 2022Frederiksberg Campus of Faculty of Science, UCPH, CopenhagenAugust
31s-September 2nd, 2022*

*Early registration deadline: August 15th AoE *

*See **https://ifl22.github.io/* <https://ifl22.github.io/>* for more
information.*

*CALL FOR PARTICIPATION:*


The 34th Symposium on Implementation and Application of Functional
Languages (IFL 2022)

Copenhagen, August 31st-September 2nd, 2022


*Important dates*


Submission deadline of draft papers   August 8th, 2022 (EXPIRED)

Notification of acceptanceAugust 9th, 2022 (EXPIRED)

Early registration deadline   August 15th, 2022 (AoE)

Late registration deadlineAugust 31st, 2022, 12:59 CET (UTC+2)

IFL Symposium August 31st - September 2nd, 2022
(We-Fr)


*Scope*


The goal of IFL is to bring together researchers and developers actively
engaged in the implementation and application of functional programming
languages and function-oriented programming. IFL 2022 is held in beautiful
Copenhagen, Denmark and is a venue for researchers to present and discuss
new ideas and concepts, work in progress, and publication-ripe results
related to the implementation and application of functional programming
languages and function-oriented programming.


*Invited speakers*


IFL 2022 is pleased to announce keynote talks by the following three
invited speakers:


* Peter Sestoft, Professor, Head of Department, IT University of
Copenhagen, Denmark: "Abstract machines and functional language
implementation"


* Lennart Augustsson, Principal Programmer, Epic Games: "Verse - a new
functional-logic language"


* Thomas Gazagnaire, Chief Technology Officer and co-founder, Tarides:
"Talk title to be announced"


*Venue and registration*


The symposium will be held physically on the Frederiksberg Campus of the
Faculty of Science at the University of Copenhagen. Days 1 and 2 (August
31st and September 1st) will be in meeting room A2-84.01 at Thorvaldsensvej
40. Day 3 (September 2nd) will be in the Celebration Auditorium at
Bülowsvej 17.


For registration and fees, please consult the symposium web site at
https://ifl22.github.io/. Please notice that the early registration date is
August 15, 2022 (AoE).


*Accepted papers*


* Asynchronous Shared Data Sources. Mart Lubbers, Haye Böhm, Pieter Koopman
and Rinus Plasmeijer.


* Heuristics-based Type Error Diagnosis for Haskell: the case of type
families. Niels Kwadijk and Jurriaan Hage.


* Verified Technology Mapping in an Agda DSL for Circuit Design. João Paulo
Pizani Flor and Wouter Swierstra.


* Creating Interactive Visualizations of TopHat Programs. Mark Gerarts,
Marc de Hoog, Nico Naus and Tim Steenvoorden.


* An SQL Frontend on top of OCaml for Data Analysis. Yan Dong, Yahui Song
and Wei-Ngan Chin.


* A Structure Editor with Type-Safe Copy/Paste. Hans Hüttel, Christoffer
Lind Andersen, Nana Gjerulf Sandberg, Anja Elisasen Lumholtz Nielsen and
Peter Mikkelsen.


* How to fold and color a map: Comparing Use-Cases of Tree-Fold vs
Fold-Left. Jim Newton.


* Compiling a functional array language with non-semantic memory
information. Philip Munksgaard, Cosmin Oancea and Troels Henriksen.


* Systems of partial values and their applications in Haskell. Natasha
England-Elbro.


* First-Class Data Types in Shallow Embedded Domain-Specific Languages
using Metaprogramming. Mart Lubbers, Pieter Koopman and Rinus Plasmeijer.


* Set-theoretic Types for Erlang. Albert Schimpf, Stefan Wehr and Annette
Bieniusa.


* Strongly-Typed Multi-View Stack-Based Computations. Pieter Koopman and
Mart Lubbers.


* Ztrategic: Strategic Programming with Zippers. José Nuno Macedo, Emanuel
Rodrigues, Marcos Viera and João Saraiva.


* Higher-ranked region inference for polymorphic, lazy languages. Ivo Gabe
de Wolff and Jurriaan Hage.


* Jeopardy: An invertible functional programming language. Joachim
Kristensen, Robin Kaarsgaard and Michael Kirkedal Thomsen.


* The Foil: Capture-Avoiding Substitution With No Sharp Edges. Dougal
Maclaurin, Alexey Radul and Adam Paszke.


* Verified Causal Broadcast with Liquid Haskell. Patrick Redmond, Gan Shen,
Niki Vazou and Lindsey Kuper.


* Towards Inversion of Tail-recursive Term Rewriting Systems. Maria Bendix
Mikkelsen, Robert Glück and Maja Hanne Kirkeby.


* A Confluence and Termination Checker for Haskell Rewrite Rules. Makoto
Hamana.


* On Generating Out-Of-Core GPU Code for Multi-Dimensional Array
Operations. Patrick van Beurden and Sven-Bodo Scholz.


* Compiling Haskell for Energy Efficiency: Analysis of Individual
Transformations. Bernardo Santos, João Fernandes, Maja Kirkeby and Alberto
Pardo.


*Post-symposium peer review *


Following IFL tradition, IFL 2022 will use a post-symposium review process
to produce the formal proceedings.


Before the symposium authors submit draft papers. These draft papers have
been screened by the program chair to make sure that they are within the
scope of IFL. The draft

[clean-list] 2nd CFP - IFL22 - The 34th Symposium on Implementation and Application of Functional Languages

2022-07-15 Thread Pieter Koopman via clean-list

*CALL FOR PAPERS:
*
The 34th Symposium on Implementation and Application of Functional
Languages (IFL 2022)

*Submission and registration are open.* See https://ifl22.github.io/.

Copenhagen, August 31st-September 2nd, 2022

*Important dates
*

Draft paper submission:  August 7th, 2022
Draft paper notification:August 9th, 2022
Early registration deadline: August 12th, 2022
Late registration deadline:  September 2nd, 2022
Symposium:   August 31st-September 2nd, 2022 (3 days)
*Scope
*
The goal of the IFL symposia is to bring together researchers actively
engaged in the implementation and application of functional and
function-based programming languages. IFL 2022 will be a venue for
researchers to present and discuss new ideas and concepts, work in
progress, and publication-ripe results related to the implementation
and application of functional languages and function-based
programming.

Topics of interest to IFL include, but are not limited to:

* language concepts
* type systems, type checking, type inferencing
* compilation techniques
* staged compilation
* run-time function specialization
* run-time code generation
* partial evaluation
* abstract interpretation
* metaprogramming
* generic programming
* automatic program generation
* array processing
* concurrent/parallel programming
* concurrent/parallel program execution
* embedded systems
* web applications
* embedded domain specific languages
* security
* novel memory management techniques
* run-time profiling performance measurements
* debugging and tracing
* virtual/abstract machine architectures
* validation, verification of functional programs
* tools and programming techniques
* industrial applications
*Submissions and peer-review
*
Following IFL tradition, IFL 2022 will use a post-symposium review
process to produce the formal proceedings.

Before the symposium authors submit draft papers. These draft papers
will be screened by the program chair to make sure that they are
within the scope of IFL. The draft papers will be made available to
all participants at the symposium. Each draft paper is presented by
one of the authors at the symposium. Notice that it is a requirement
that accepted draft papers are presented physically at the symposium.

After the symposium, a formal review process will take place,
conducted by the program committee.  Reviewing is single blind. There
will be at least 3 reviews per paper. The reviewers have 6 weeks to
write their reviews. For the camera-ready version the authors can make
minor revisions which are accepted without further reviewing.

Contributions submitted for the draft paper deadline must be between
two and twelve pages long. For submission details, please consult the
IFL 2022 website at https://ifl22.github.io/.
*Where
*
IFL 2022 will be held physically in Copenhagen, Denmark, arranged by
DIKU at the University of Copenhagen.

See the IFL 2022 website at https://ifl22.github.io/ for more
information.

[image: beacon]
___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] CALL FOR PAPERS - IFL22 - The 34th Symposium on Implementation and Application of Functional Languages

2022-06-13 Thread Pieter Koopman via clean-list

*CALL FOR PAPERS - The 34th Symposium on Implementation and Application of
Functional Languages*

*Important dates*
Draft paper submission:7th of August 2022
Draft paper notification:  9th of August 2022
Registration deadline:12th of August 2022
Symposium:31th of August to 2nd of September

*Scope*
The goal of the IFL symposia is to bring together researchers actively
engaged in the implementation and application of functional
and function-based programming languages. IFL 2022 will be a venue for
researchers to present and discuss new ideas and concepts, work in
progress, and publication-ripe results related to the implementation and
application of functional languages and function-based programming.

Topics of interest to IFL include, but are not limited to:
* language concepts
* type systems, type checking, type inferencing
* compilation techniques
* staged compilation
* run-time function specialization
* run-time code generation
* partial evaluation
* abstract interpretation
* metaprogramming
* generic programming
* automatic program generation
* array processing
* concurrent/parallel programming
* concurrent/parallel program execution
* embedded systems
* web applications
* embedded domain specific languages
* security
* novel memory management techniques
* run-time profiling performance measurements
* debugging and tracing
* virtual/abstract machine architectures
* validation, verification of functional programs
* tools and programming techniques
* industrial applications

*Submissions and peer-review*
Following IFL tradition, IFL 2022 will use a post-symposium review process
to produce the formal proceedings.

Before the symposium authors submit draft papers. These draft papers will
be screened by the program chair to make sure that they are within the
scope of IFL. The draft papers will be made available to all participants
at the symposium. Each draft paper is presented by one of the authors at
the symposium.

After the symposium, a formal review process will take place, conducted by
the program committee.  Reviewing is single blind. There will be at least 3
reviews per paper. The reviewers have 6 weeks to write their reviews. For
the camera-ready version the authors can make minor revisions which are
accepted without further reviewing.

*Where*
IFL 2022 will be held physically in Copenhagen, Denmark, arranged by DIKU
at the University of Copenhagen.

See the IFL 2022 website at https://ifl22.github.io/ for more information.
[image: beacon]
___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL'21 final call for participation

2021-08-30 Thread Pieter Koopman via clean-list





IFL 2021



33rd Symposium on Implementation and Application of Functional Languages





 venue: online

  1 - 3 September 2021



 https://ifl21.cs.ru.nl
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-31163156=YAMMID-51932978=https://ifl21.cs.ru.nl/>





*Registration*


*Registration is **free of charge, but required for participation!* We will
mail the zoom link only to registered participants. Use the below link to
register for IFL 2021:



https://docs.google.com/forms/d/e/1FAIpQLSdMFjo-GumKjk4i7szs7n4DhWqKt96t8ofIqshfQFrf4jnvsA/viewform?usp=sf_link
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-31163156=YAMMID-51932978=https://docs.google.com/forms/d/e/1FAIpQLSdMFjo-GumKjk4i7szs7n4DhWqKt96t8ofIqshfQFrf4jnvsA/viewform?usp=sf_link>



*Program*

The program is now available at https://ifl21.cs.ru.nl/Program
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-31163156=YAMMID-51932978=https://ifl21.cs.ru.nl/Program>
.

*Scope*

The goal of the IFL symposia is to bring together researchers actively
engaged in the implementation and application of functional and
function-based programming languages. IFL 2021 will be a venue for
researchers to present and discuss new ideas and concepts, work in
progress, and publication-ripe results related to the implementation and
application of functional languages and function-based programming.



*Organisation*

IFL 2021 Chairs: Pieter Koopman and Peter Achten, Radboud University, The
Netherlands

IFL Publicity chair: Pieter Koopman, Radboud University, The Netherlands



*PC*

Peter Achten (co-chair)   - Radboud University, Netherlands

Thomas van Binsbergen - University of Amsterdam, Netherlands

Edwin Brady   - University of St. Andrews, Scotland

Laura Castro  - University of A Coruña, Spain

Youyou Cong   - Tokyo Institute of Technology, Japan

Olaf Chitil   - University of Kent, England

Andy Gill - University of Kansas, USA

Clemens Grelck- University of Amsterdam, Netherlands

John Hughes   - Chalmers University, Sweden

Pieter Koopman (co-chair) - Radboud University, Netherlands

Cynthia Kop   - Radboud University, Netherlands

Jay McCarthey - University of Massachussetts Lowell, USA

Neil Mitchell - Facebook, England

Jan De Muijnck-Hughes - Glasgow University, Scotland

Keiko Nakata  - SAP Innovation Center Potsdam, Germany

Jurriën Stutterheim   - Standard Chartered, Singapore

Simon Thompson- University of Kent, England

Melinda Tóth  - Eötvos Loránd University, Hungary

Phil Trinder  - Glasgow University, Scotland

Meng Wang - University of Bristol, England

Viktória Zsók - Eötvos Loránd University, Hungary
[image: beacon]
___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL'21 call for participation

2021-08-25 Thread Pieter Koopman via clean-list





IFL 2021



33rd Symposium on Implementation and Application of Functional Languages





 venue: online

  1 - 3 September 2021



 https://ifl21.cs.ru.nl
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-315504601=YAMMID-07845501=https%3A%2F%2Fifl21.cs.ru.nl>





*Registration*


Registration is free of charge, but required for participation! Use the
below link to register for IFL 2021:



https://docs.google.com/forms/d/e/1FAIpQLSdMFjo-GumKjk4i7szs7n4DhWqKt96t8ofIqshfQFrf4jnvsA/viewform?usp=sf_link
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-315504601=YAMMID-07845501=https%3A%2F%2Fdocs.google.com%2Fforms%2Fd%2Fe%2F1FAIpQLSdMFjo-GumKjk4i7szs7n4DhWqKt96t8ofIqshfQFrf4jnvsA%2Fviewform%3Fusp%3Dsf_link>



*Scope*


The goal of the IFL symposia is to bring together researchers actively
engaged in the implementation and application of functional and
function-based programming languages. IFL 2021 will be a venue for
researchers to present and discuss new ideas and concepts, work in
progress, and publication-ripe results related to the implementation and
application of functional languages and function-based programming.



*Program*

The program is now available at https://ifl21.cs.ru.nl/Program
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-315504601=YAMMID-07845501=https%3A%2F%2Fifl21.cs.ru.nl%2FProgram>
.



*Organisation*

IFL 2021 Chairs: Pieter Koopman and Peter Achten, Radboud University, The
Netherlands

IFL Publicity chair: Pieter Koopman, Radboud University, The Netherlands



*PC*

Peter Achten (co-chair)   - Radboud University, Netherlands

Thomas van Binsbergen - University of Amsterdam, Netherlands

Edwin Brady   - University of St. Andrews, Scotland

Laura Castro  - University of A Coruña, Spain

Youyou Cong   - Tokyo Institute of Technology, Japan

Olaf Chitil   - University of Kent, England

Andy Gill - University of Kansas, USA

Clemens Grelck- University of Amsterdam, Netherlands

John Hughes   - Chalmers University, Sweden

Pieter Koopman (co-chair) - Radboud University, Netherlands

Cynthia Kop   - Radboud University, Netherlands

Jay McCarthey - University of Massachussetts Lowell, USA

Neil Mitchell - Facebook, England

Jan De Muijnck-Hughes - Glasgow University, Scotland

Keiko Nakata  - SAP Innovation Center Potsdam, Germany

Jurriën Stutterheim   - Standard Chartered, Singapore

Simon Thompson- University of Kent, England

Melinda Tóth  - Eötvos Loránd University, Hungary

Phil Trinder  - Glasgow University, Scotland

Meng Wang - University of Bristol, England

Viktória Zsók - Eötvos Loránd University, Hungary
[image: beacon]
___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL'21 Final call for papers

2021-08-05 Thread Pieter Koopman via clean-list

BhfIIDW1X2vaVQE-1790158325=YAMMID-96810236=https%3A%2F%2Feasychair.org%2Fconferences%2F%3Fconf%3Difl21>
.

Peter Landin Prize

The Peter Landin Prize is awarded to the best paper presented at the
symposium every year. The honoured article is selected by the program
committee
based on the submissions received for the formal review process. The prize
carries a cash award equivalent to 150 Euros.

Organisation

IFL 2021 Chairs: Pieter Koopman and Peter Achten, Radboud University, The
Netherlands

IFL Publicity chair: Pieter Koopman, Radboud University, The Netherlands

PC:
Peter Achten (co-chair)   - Radboud University, Netherlands
Thomas van Binsbergen - University of Amsterdam, Netherlands
Edwin Brady   - University of St. Andrews, Scotland
Laura Castro  - University of A Coruña, Spain
Youyou Cong   - Tokyo Institute of Technology, Japan
Olaf Chitil   - University of Kent, England
Andy Gill - University of Kansas, USA
Clemens Grelck- University of Amsterdam, Netherlands
John Hughes   - Chalmers University, Sweden
Pieter Koopman (co-chair) - Radboud University, Netherlands
Cynthia Kop   - Radboud University, Netherlands
Jay McCarthey - University of Massachussetts Lowell, USA
Neil Mitchell - Facebook, England
Jan De Muijnck-Hughes - Glasgow University, Scotland
Keiko Nakata  - SAP Innovation Center Potsdam, Germany
Jurriën Stutterheim   - Standard Chartered, Singapore
Simon Thompson- University of Kent, England
Melinda Tóth  - Eötvos Loránd University, Hungary
Phil Trinder  - Glasgow University, Scotland
Meng Wang - University of Bristol, England
Viktória Zsók - Eötvos Loránd University, Hungary


Virtual symposium

Because of the Covid-19 pandemic, this year IFL 2021 will be an online
event,
consisting of paper presentations, discussions and virtual social
gatherings.
Registered participants can take part from anywhere in the world.

Registration

Please use the link below to register for IFL 2021:
https://docs.google.com/forms/d/e/1FAIpQLSdMFjo-GumKjk4i7szs7n4DhWqKt96t8ofIqshfQFrf4jnvsA/viewform?usp=sf_link
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-1790158325=YAMMID-96810236=https%3A%2F%2Fdocs.google.com%2Fforms%2Fd%2Fe%2F1FAIpQLSdMFjo-GumKjk4i7szs7n4DhWqKt96t8ofIqshfQFrf4jnvsA%2Fviewform%3Fusp%3Dsf_link>
Thanks to the sponsors and the support of the Radboud university
registration is free of charge.
[image: beacon]
___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL'21 Third call for papers

2021-07-08 Thread Pieter Koopman via clean-list

Fconferences%2F%3Fconf%3Difl21>
.

Peter Landin Prize

The Peter Landin Prize is awarded to the best paper presented at the
symposium every year. The honoured article is selected by the program
committee
based on the submissions received for the formal review process. The prize
carries a cash award equivalent to 150 Euros.

Organisation

IFL 2021 Chairs: Pieter Koopman and Peter Achten, Radboud University, The
Netherlands

IFL Publicity chair: Pieter Koopman, Radboud University, The Netherlands

PC:
Peter Achten (co-chair)   - Radboud University, Netherlands
Thomas van Binsbergen - University of Amsterdam, Netherlands
Edwin Brady   - University of St. Andrews, Scotland
Laura Castro  - University of A Coruña, Spain
Youyou Cong   - Tokyo Institute of Technology, Japan
Olaf Chitil   - University of Kent, England
Andy Gill - University of Kansas, USA
Clemens Grelck- University of Amsterdam, Netherlands
John Hughes   - Chalmers University, Sweden
Pieter Koopman (co-chair) - Radboud University, Netherlands
Cynthia Kop   - Radboud University, Netherlands
Jay McCarthey - University of Massachussetts Lowell, USA
Neil Mitchell - Facebook, England
Jan De Muijnck-Hughes - Glasgow University, Scotland
Keiko Nakata  - SAP Innovation Center Potsdam, Germany
Jurriën Stutterheim   - Standard Chartered, Singapore
Simon Thompson- University of Kent, England
Melinda Tóth  - Eötvos Loránd University, Hungary
Phil Trinder  - Glasgow University, Scotland
Meng Wang - University of Bristol, England
Viktória Zsók - Eötvos Loránd University, Hungary


Virtual symposium

Because of the Covid-19 pandemic, this year IFL 2021 will be an online
event,
consisting of paper presentations, discussions and virtual social
gatherings.
Registered participants can take part from anywhere in the world.

Registration

Please use the below link to register for IFL 2021:
https://docs.google.com/forms/d/e/1FAIpQLSdMFjo-GumKjk4i7szs7n4DhWqKt96t8ofIqshfQFrf4jnvsA/viewform?usp=sf_link
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-0=YAMMID-10128524=https%3A%2F%2Fdocs.google.com%2Fforms%2Fd%2Fe%2F1FAIpQLSdMFjo-GumKjk4i7szs7n4DhWqKt96t8ofIqshfQFrf4jnvsA%2Fviewform%3Fusp%3Dsf_link>
Thanks to the sponsors and the support of the Radboud university
registration is free of charge.

[image: beacon]
___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL2021 second call for papers

2021-06-15 Thread Pieter Koopman via clean-list

D-70938406=http%3A%2F%2Fwww.acm.org%2Fpublications%2Fproceedings-template>

The submission Web page for IFL21 is
https://easychair.org/conferences/?conf=ifl21
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-123424015=YAMMID-70938406=https%3A%2F%2Feasychair.org%2Fconferences%2F%3Fconf%3Difl21>
.

Peter Landin Prize

The Peter Landin Prize is awarded to the best paper presented at the
symposium every year. The honoured article is selected by the program
committee
based on the submissions received for the formal review process. The prize
carries a cash award equivalent to 150 Euros.

Organisation

IFL 2021 Chairs: Pieter Koopman and Peter Achten, Radboud University, The
Netherlands

IFL Publicity chair: Pieter Koopman, Radboud University, The Netherlands

PC:
Peter Achten (co-chair)   - Radboud University, Netherlands
Thomas van Binsbergen - University of Amsterdam, Netherlands
Edwin Brady   - University of St. Andrews, Scotland
Laura Castro  - University of A Coruña, Spain
Youyou Cong   - Tokyo Institute of Technology, Japan
Olaf Chitil   - University of Kent, England
Andy Gill - University of Kansas, USA
Clemens Grelck- University of Amsterdam, Netherlands
John Hughes   - Chalmers University, Sweden
Pieter Koopman (co-chair) - Radboud University, Netherlands
Cynthia Kop   - Radboud University, Netherlands
Jay McCarthey - University of Massachussetts Lowell, USA
Neil Mitchell - Facebook, England
Jan De Muijnck-Hughes - Glasgow University, Scotland
Keiko Nakata  - SAP Innovation Center Potsdam, Germany
Jurriën Stutterheim   - Standard Chartered, Singapore
Simon Thompson- University of Kent, England
Melinda Tóth  - Eötvos Loránd University, Hungary
Phil Trinder  - Glasgow University, Scotland
Meng Wang - University of Bristol, England
Viktória Zsók - Eötvos Loránd University, Hungary


Virtual symposium

Because of the Covid-19 pandemic, this year IFL 2021 will be an online
event,
consisting of paper presentations, discussions and virtual social
gatherings.
Registered participants can take part from anywhere in the world.


[image: beacon]
___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL2021 First call for papers

2021-03-25 Thread Pieter Koopman



IFL 2021

33rd Symposium on Implementation and Application of Functional Languages


 venue: online
  1 - 3 September 2021

 https://ifl21.cs.ru.nl
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-0=YAMMID-01539123=https%3A%2F%2Fifl21.cs.ru.nl>



Scope

The goal of the IFL symposia is to bring together researchers actively
engaged
in the implementation and application of functional and function-based
programming languages. IFL 2021 will be a venue for researchers to present
and
discuss new ideas and concepts, work in progress, and publication-ripe
results
related to the implementation and application of functional languages and
function-based programming.


Industrial track and topics of interest

This year's edition of IFL explicitly solicits original work concerning
*applications*
of functional programming in industry and academia. These contributions
will be reviewed by experts with an industrial background.

Topics of interest to IFL include, but are not limited to:

* language concepts
* type systems, type checking, type inferencing
* compilation techniques
* staged compilation
* run-time function specialisation
* run-time code generation
* partial evaluation
* (abstract) interpretation
* meta-programming
* generic programming
* automatic program generation
* array processing
* concurrent/parallel programming
* concurrent/parallel program execution
* embedded systems
* web applications
* (embedded) domain-specific languages
* security
* novel memory management techniques
* run-time profiling performance measurements
* debugging and tracing
* testing and proofing
* virtual/abstract machine architectures
* validation, verification of functional programs
* tools and programming techniques
* applications of functional programming in the industry, including
** functional programming techniques for large applications
** successes of the application functional programming
** challenges for functional programming encountered
** any topic related to the application of functional programming that is
interesting for the IFL community


Post-symposium peer-review

Following IFL tradition, IFL 2021 will use a post-symposium review process
to
produce the formal proceedings.

Before the symposium authors submit draft papers. These draft papers will
be
screened by the program chairs to make sure that they are within the scope
of
IFL. The draft papers will be made available to all participants at the
symposium. Each draft paper is presented by one of the authors at the
symposium.

After the symposium every presenter is invited to submit a full paper,
incorporating feedback from discussions at the symposium. Work submitted to
IFL
may not be simultaneously submitted to other venues; submissions must
adhere to ACM SIGPLAN's republication policy. The program committee will
evaluate these submissions according to their correctness, novelty,
originality,
relevance, significance, and clarity, and will thereby determine whether
the
paper is accepted or rejected for the formal proceedings. We plan to
publish
these proceedings in the International Conference Proceedings Series of the
ACM Digital Library, as in previous years. Moreover, the proceedings will
also
be made publicly available as open access.


Important dates

Submission deadline of draft papers:   17 August 2021
Notification of acceptance for presentation:   19 August 2021
Registration deadline: 30 August 2021
IFL Symposium: 1-3 September 2021
Submission of papers for proceedings:  6 December 2021
Notification of acceptance:3 February 2022
Camera-ready version:  15 March 2022


### Submission details

All contributions must be written in English. Papers must use the ACM two
columns conference format, which can be found at:

  http://www.acm.org/publications/proceedings-template
<https://ifl21-publicity-dot-yamm-track.appspot.com/Redirect?ukey=1NdKhGOLpmlYX_0BVua0V5yyanFkJBhfIIDW1X2vaVQE-0=YAMMID-01539123=http%3A%2F%2Fwww.acm.org%2Fpublications%2Fproceedings-template>


Peter Landin Prize

The Peter Landin Prize is awarded to the best paper presented at the
symposium every year. The honoured article is selected by the program
committee
based on the submissions received for the formal review process. The prize
carries a cash award equivalent to 150 Euros.


Organisation

IFL 2021 Chairs: Pieter Koopman and Peter Achten, Radboud University, The
Netherlands

IFL Publicity chair: Pieter Koopman, Radboud University, The Netherlands

PC (under construction):
Peter Achten (co-chair)   - Radbou

[clean-list] CfP for TFPIE 19

2019-05-03 Thread Pieter Koopman



TFPIE 2019 Call for papers
http://www.staff.science.uu.nl/~hage0101/tfpie2019/index.html
(June 11th, University of British Columbia, Vancouver Canada, co-located 
with TFP 2019)


TFPIE 2019 welcomes submissions describing techniques used in the 
classroom, tools used in and/or developed for the classroom and any 
creative use of functional programming (FP) to aid education in or 
outside Computer Science. Topics of interest include, but are not 
limited to:


FP and beginning CS students
FP and Computational Thinking
FP and Artificial Intelligence
FP in Robotics
FP and Music
Advanced FP for undergraduates
FP in graduate education
Engaging students in research using FP
FP in Programming Languages
FP in the high school curriculum
FP as a stepping stone to other CS topics
FP and Philosophy
The pedagogy of teaching FP
FP and e-learning: MOOCs, automated assessment etc.
Best Lectures – more details below

In addition to papers, we are requesting best lecture presentations. 
What’s your
best lecture topic in an FP related course? Do you have a fun way to 
present FP

concepts to novices or perhaps an especially interesting presentation of a
difficult topic? In either case, please consider sharing it. Best 
lecture topics

will be selected for presentation based on a short abstract describing the
lecture and its interest to TFPIE attendees. The length of the presentation
should be comparable to that of a paper. On top of the lecture itself, 
the presentation can also provide commentary on the lecture.


Submissions
Potential presenters are invited to submit an extended abstract (4-6 
pages) or a

draft paper (up to 16 pages) in EPTCS style. The authors of accepted
presentations will have their preprints and their slides made available 
on the
workshop's website. Papers and abstracts can be submitted via easychair 
at the

following link: https://easychair.org/conferences/?conf=tfpie2019 After the
workshop, presenters will be invited to submit (a revised version of) their
article for review. The PC will select the best articles that will be 
published in the Electronic Proceedings in Theoretical Computer Science 
(EPTCS).
Articles rejected for presentation and extended abstracts will not be 
formally

reviewed by the PC.

Dates
Submission deadline: May 14th 2019, Anywhere on Earth.
Notification: May 20th
Workshop: June 11th
Submission for formal review: August 18th 2019, Anywhere on Earth
Notification of full article: October 6th
Camera ready: November 1st

Program Committee

Alex Gerdes - University of Gothenburg / Chalmers
Jurriaan Hage (Chair) - Utrecht University
Pieter Koopman - Radboud University, the Netherlands
Elena Machkasova - University of Minnesota, Morris, USA
Heather Miller - Carnegie Mellon University and EPFL Lausanne
Prabhakar Ragde - University of Waterloo, Waterloo, Ontario, Canada
Simon Thompson - University of Kent, UK
Sharon Tuttle - Humboldt State University, Arcata, USA

Note: information on TFP is available at https://www.tfp2019.org/index.html



___
clean-list mailing list
clean-list@science.ru.nl
https://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] Fwd: [TFP-AC] EAPLS Best PhD Award 2014

2015-03-04 Thread Pieter Koopman



European colleagues: please circulate widely theattached call for 
submission for the EAPLS 2014 Best PhD Award. A text version follows.


EAPLS PhD Award 2014: Call for Nominations 
==


URL: http://eapls.org/pages/phd_award/

The European Association for Programming Languages and Systems has 
established a Best Dissertation Award in the international research area 
of programming languages and systems. The award will go to the PhD 
student who in the previous period has made the most original and 
influential contribution to the area. The purpose of the award is to 
draw attention to excellent work, to help the career of the student in 
question, and to promote the research field as a whole.


Eligibility

---

Eligible for the award are those who successfully defended their PhD

* at an academic institution in Europe

* in the field of Programming Languages and Systems

* in the period from 1 November 2013 – 31 December 2014

Nominations

---

Candidates for the award must be nominated by their supervisor.

Nominating a candidate consists of submitting the thesis to 
https://easychair.org/conferences/?conf=eaplsphd2014. The nomination 
must be accompanied by (a zip file containing)


* a letter from the supervisor describing why the thesis should be

considered for the award;

* a report from an independent researcher who has acted as examiner

   of the thesis at its defense.

The theses will be evaluated with respect to originality, influence, 
relevance to the field and (to a lesser degree) quality of writing.


Procedure

-

The nominations will be evaluated and compared by an international 
committee of experts from across Europe. The procedure to be followed is 
analogous to the review phase of a conference. The justification by the 
supervisor and the external report will play an important role in the 
evaluation.


Members of the expert committee are barred from nominating their own PhD 
students for the award.


The award consists of a certificate announcing the winner to have 
received the EAPLS PhD award 2014. The supervisor will receive a copy of 
this certificate. If possible, the certificate will be handed out 
ceremonially at a suitable occasion, as for instance the ETAPS conference.


Apart from the winner, no further ranking of nominees will be published. 
The decision of the expert committee is final and binding, and will not 
be subject to discussion.


Important dates

---

31 March 2015: Deadline for nominations

31 July 2015:Announcement of the award winner

Expert committee



The Expert committee includes:

* Eerke Boiten, University of Kent, U.K.

* Mark van den Brand, Universiteit Eindhoven, The Netherlands

* Paolo Ciancarini, Universita di Bologna, Italy

* Stefano Crespi Reghizzi, Politecnico di Milano, Italy

* Kei Davis, Los Alamos National Laboratory, U.S.A.

* Mariangiola Dezani, Universita di Torino, Italy

* Josuka Díaz-Labrador, Universidad de Duesto, Spain

* Marko van Eekelen, Radboud Universiteit Nijmegen, The Netherlands

* Giorgio Ghelli, University of Pisa, Italy

* Sabine Glesner, Technische Universität Berlin

* Stefan Gruner, University of Pretoria, South Africa

* Kevin Hammond, University of St Andrews, U.K.

* Martin Hofmann, Ludwig-Maximilians-Universität München, Germany

* Paul Klint, CWI and University of Amsterdam, The Netherlands

* Jens Knoop, Technische Universität Wien, Austria

* Ralf Lämmel, University of Koblenz-Landau, Germany

* Rita Loogen, Philipps-Universität Marburg, Germany

* Tiziana Margaria, University of Potsdam, Germany

* Greg Michaelson, Heriot-Watt University , Edinburgh, U.K.

* Alan Mycroft, University of Cambridge, U.K.

* Ricardo Peña, Universidad Complutense de Madrid, Spain

* Arnd Poetzsch-Heffter, Technische Universität Kaiserslautern, Germany

* Arend Rensink, Universiteit Twente, The Netherlands

* Bernhard Steffen, Technische Universität Dortmund, Germany

* Baltasar Trancon Widemann, Technische Universität Ilmenau, Germany

* Peter Van Roy, Université Catholique de Louvain, Belgium





EAPLS PhD Award 2014.docx
Description: MS-Word 2007 document
___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] hd (drop 1000000 [1..]) heapFull

2013-07-19 Thread Pieter Koopman


Hi Erik,

there seems to be a problem with the generator.

Start = hd (drop  n [1..n+10]) where n = 100

works fine. Hopefully John can explain this.

Best, Pieter

On 7/19/13 4:41 PM, zuurb...@planet.nl wrote:

Re: [clean-list] Matrix operations
Start = hd (drop 100 [1..])
with standard heap (2M) leads to a heapfull message; not when I only 
drop 1000.
I had expected the garbage collector to kick in so this would 
effectively run in constant space

Any ideas?


___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list


___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] Is there a REPL??

2012-10-21 Thread Pieter Koopman


Hi Duke,

Nice that you try Clean.
There is no read-eval-print-loopin Clean. In an average machine the 
compiler is more than fast enough to compilea simple module with the 
function


Start = /your //expression//
/
and to execute it (with ctrl-R).

Have fun,

Pieter

On 20/10/2012 1:12 AM, Duke Normandin wrote:

Hi ...

I'm a total Clean noob, and still very green with the FP mind-set. 
And to make it worse, I hate math. LOL ...


Anyway, the CleanIDE is very cool, but is there a REPL to fool around 
with? I'm on Win7, BTW.  TIA ...


___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] Memoization of recursive functions using Clean arrays

2012-08-24 Thread Pieter Koopman


Hi Maks,

Your typed identity function

idLazyArray :: {a} - {a}
idLazyArray a = a

is a smart way to solve the overloading for the array.

Adding a type to a local definition always turns it into a function. 
This explains way adding a type to memo makes your program slow. You are 
completely right: the compiler should complain if it wants to treat a 
definition as a function while the user indicates with a =: that it 
should be a constant.


In the future we will most likely add special notation to indicate 
strict or unboxed arrays. For situations like this it is also desirable 
to have syntax that indicates lazy arrays.


In some situations it is desirable to be able to indicate the type of 
local constants. A Haskell like notation to indicate the type of 
expressions is a solution we are considering.


Best, Pieter

On 22/08/2012 8:44 PM, Maks Verver wrote:

On Tue, 21 Aug 2012 13:16:51 +0200
Pieter Koopman pie...@cs.ru.nl wrote:

1) Most likely you have to recompile _SystemArray with the -ci flag
(throw away the .o object file).

That's it.  For future reference, I did this:

   make -C path-to-clean-dir CLMFLAGS+=-ci cleanup install



2) For instance
memoize :: ((Int - e) - (Int - e)) Int - (Int - e)
memoize f max = select (memo f max)
where
  memo :: ((Int - e) - (Int - e)) Int - {e}
  memo f max = array
  where array = { f (select array) i \\ i - [0..max] }

I see.  That's a useful trick, though in this case you've reshuffled
the definitions considerably.

In this case I can also fix my problem by introducing a function to
restrict the kind of array used:

   lazyArray :: u:{a} - u:{a}
   lazyArray a = a

And then stay relatively close to the original, simpler definition:

   memoize :: ((Int - a) - Int - a) Int - (Int - a)
   memoize f max = g
   where g = select (lazyArray {f g i \\ i - [0..max]})


The standard solution is to add an argument to fix the the type.

I can't imagine that's always a nice solution, considering that adding
an argument to a constant expression apparently affects the efficiency
of the resulting program.



3) It is essential to define the memo object as a local constant,
that is a definition without arguments. In that way it will become a
local graph which is shared in all compuations. Each local definition
with arguments is a function. Functions are lifted to the global
level by the compiler an evaluated for each argument all over again.
This is exactly what you try to avoid.

This sounds reasonable but I still have trouble applying this to
concrete programs.  For example, it doesn't explain why this is fast,
even though I use a lambda-closure:

   memoize :: ((Int - Int) - Int - Int) Int - (Int - Int)
   memoize f max = g
   where
   g = \i - memo.[i]
   memo =: lazyArray { f g i \\ i - [0..max] }

... while adding a type to memo makes it slow:

   memoize :: ((Int - Int) - Int - Int) Int - (Int - Int)
   memoize f max = g
   where
   g = \i - memo.[i]
   memo :: {Int}  // -- only added this
   memo =: lazyArray { f g i \\ i - [0..max] }

What is the type inferred by the compiler in the first case that would
result in a completely different kind of evaluation?

Or does adding a type declaration turn `memo' from a graph into a
(constant) function?  In that case, shouldn't the compiler reject my
use of `=:' instead of `='?

  - Maks.


___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] Memoization of recursive functions using Clean arrays

2012-08-21 Thread Pieter Koopman


Hi Maks,

1) Most likely you have to recompile _SystemArray with the -ci flag 
(throw away the .o object file).


2) For instance
memoize :: ((Int - e) - (Int - e)) Int - (Int - e)
memoize f max = select (memo f max)
where
memo :: ((Int - e) - (Int - e)) Int - {e}
memo f max = array
where array = { f (select array) i \\ i - [0..max] }

fib :: (Int - Int)
fib =: memoize fib_rec 1

The essential thing is that you need to specify what kind of array you 
want in order to solve the overloading. When you do this directly the 
type of a local an global type variable have to be equal, this is 
something the type checker does not like. The standard solution is to 
add an argument to fix the the type. The additional level of local 
functions solve all problems. Here it is 'accidental' that memoize and 
memo use the same type variable e, it are different variables.


3) It is essential to define the memo object as a local constant, that 
is a definition without arguments. In that way it will become a local 
graph which is shared in all compuations. Each local definition with 
arguments is a function. Functions are lifted to the global level by the 
compiler an evaluated for each argument all over again. This is exactly 
what you try to avoid.
\y - f x y is a (anonymous) function, while f x is just a function 
application. They are beta equal (that is: they reduce to the same 
value) but not operational equal.


Have fun,

Pieter

On 20/08/2012 5:15 PM, Maks Verver wrote:

Hi Pieter,

On Mon, 20 Aug 2012 12:54:38 +0200
Pieter Koopman pie...@cs.ru.nl wrote:

By using =: in the definition of memo instead of =, you create a
graph that is evaluated at most once.

Thanks, I had overlooked the differences between graphs/constants and
global/local definitions.  Using =: does allow me to solve my problems,
but it also raises a couple more questions.

I've now rewritten my code like this:

   fib_rec :: (Int - Int) Int - Int
   fib_rec _ 0 = 0
   fib_rec _ 1 = 1
   fib_rec f i = (f (i - 2) + f (i - 1)) rem 100

   memoize :: ((Int - Int) - Int - Int) Int - (Int - Int)
   memoize f max = g
   where
   g = select memo
   memo :: {Int}
   memo = { f g i \\ i - [0..max] }

   fib =: memoize fib_rec 1

The =: in the last line is required to prevent the memo from being
recomputed unnecessarily.  However, there are a couple of weird
things about this code:

  1. My program segfaults when I try to call fib with an argument
outside the range of the array, even when compiling with -ci.  Of
course that can't work, but I'd expect an array-index-out-of-bounds
error in that case.  Could this be a bug in the code generator?

  2. I'd like the type of `memoize' to be ((Int - a) - Int - a) Int -
(Int - a).  But in that case I don't know how to type memo; {a} is not
allowed, and omitting the type of memo entirely fails due to unresolved
overloading.  Is there a solution for this?

  3. The desired sharing of memo seems to occur only if I define g as a
partially applied function.  For example, defining:
 g i = memo.[i]
or:
 g i = select memo i
or:
 g =: \i - memo.[i]
... results in the memo being recomputed for every invocation of g (and
thus exponential runtime).  But if I use a list instead of an array
for the memo, this doesn't occur: `g i = memo!!i' works fine.

Apparently (\y - f x y) isn't equivalent to (f x).  That's really
surprising!

  - Maks.


___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] Memoization of recursive functions using Clean arrays

2012-08-17 Thread Pieter Koopman


Hi Maks,

The problem is that you need inline updates of your array to obtain the 
desired memoization effect. The way to obtain inline updates is to 
create an array and to pass it as a unique object in your function f.
You can obtain an element from a unique array and use the array again as 
an unique object with the operator !.

For instance:

fib j =  memo.[j]
where
memo :: {#Int}
memo = f 2 {createArray (max (j+1) 2) 0  [1] = 1}

f :: !Int *{#Int} - *{#Int}
f i a
| i  j
= a
# (x,a) = a![i-1]
  (y,a) = a![i-2]
= f (i+1) {a  [i] = (x+y) rem 10^6}

A recursive reference implementation with is O(n) is:

fibrec j = f 0 0 1
where
f :: !Int !Int !Int - Int
f i x y
| i == j
= x
= f (i+1) y ((x+y) rem 10^6)

A simple test to see if this works:

Start = and [fib i == fibrec i \\ i -[0..1000]]

On may slow laptop this is yields True in 0.01 s.
This is of course rather inefficient: it creates 1001 times an array for 
memoization. It is better to use one memo array for every call to fib 
instead of creating a new one array for each call:


fib j =  memo.[j]

memo :: {#Int}
memo =: f 2 {createArray (max (MaxFib+1) 2) 0  [1] = 1}
where
f :: !Int *{#Int} - *{#Int}
f i a
| i  MaxFib
= a
# (x,a) = a![i-1]
  (y,a) = a![i-2]
= f (i+1) {a  [i] = (x+y) rem 10^6}

Have fun,

Pieter



On 17/08/2012 4:19 PM, Maks Verver wrote:

Hi everyone,

In Haskell, an easy and efficient way to apply memoization to a
recursive function is to create an array which holds all values in the
(desired) domain of that function, and index that array instead of
calling the function directly.

For example, the Fibonacci function modulo 1,000,000 could be
implemented recursively as:

   fib_slow 0 = 0
   fib_slow 1 = 1
   fib_slow i = fib_slow (i - 2) + fib_slow (i - 1) `mod` 100

But of course this is very slow for values of i  25 or so.  If the
range of the argument is known (for example i = 1000) then an easy
solution is to cache values in an array:

   fib = (!)memo
   where
   memo = array (0,1000) [ (i, f i) | i - [0..] ]
   f 0 = 0
   f 1 = 1
   f i = fib (i - 2) + fib (i - 1) `mod` 100

Note that the definition of f mirrors that of fib_slow, except that it
calls the memoized function fib instead of itself.  This is quite fast;
not just because of memoization but also because array elements are
only computed when needed.  So f is called at most 1,001 times.

I tried to recreate this pattern in Clean but did not get it to work as
desired.  For example, consider the following equivalent-looking Clean
code:

   fib i = memo.[i]
   where
   memo :: {Int}
   memo = { f i \\ i - [0..1000] }
   f 0 = 0
   f 1 = 1
   f i = (memo.[i - 1] + memo.[i - 2]) rem 100

Computing fib 100 takes forever (without using much memory) as if no
memoization applies.  However, making the array strict/unboxed (memo ::
{!Int} or {#Int}) yields a Heap full. error as soon as the function
is called.

So apparently arrays in Clean do not work as I expected/was used to
from Haskell.  How should I understand what happens here?  Is there a
way to make memoization work like this in Clean?  If so, how?  If not,
what is a good alternative?

Kind regards,
Maks Verver.
___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list


___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL2012: call for papers

2012-05-24 Thread Pieter Koopman

-Original Message-
From: Ralf Hinze
Sent: Wednesday, May 23, 2012 12:34 PM
Subject: IFL2012: call for papers

Dear all,

I am sending out the Call for Papers (attached) today. May I ask you to 
distribute the CFP locally. Also, let your students and colleagues know.
You can find a PDF version here: 
http://www.cs.ox.ac.uk/conferences/IFL2012/cfp.pdf

Furthermore, please add a link to the IFL Website 
http://www.cs.ox.ac.uk/conferences/IFL2012/ in a prominent place on your 
homepage.

Thanks, Ralf

---

   CALL FOR PAPERS

 24th Symposium on Implementation and
Application of Functional Languages (IFL 2012)

   University of Oxford, UK, August 30-September 1, 2012

 http://www.cs.ox.ac.uk/conferences/IFL2012/

This year IFL will be hosted by the University of Oxford, within the
idyllic setting of the dreaming spires and picturesque colleges, which
have been the home to academic endeavour and research for over nine
centuries. The symposium will be held between 30 August and
1 September, 2012.

Scope
-

The goal of the IFL symposia is to bring together researchers actively
engaged in the implementation and application of functional and
function-based programming languages. IFL 2012 will be a venue for
researchers to present and discuss new ideas and concepts, work in
progress, and publication-ripe results related to the implementation
and application of functional languages and function-based
programming.

Following the IFL tradition, IFL 2012 will use a post-symposium review
process to produce formal proceedings which will be published by
Springer Verlag in the Lecture Notes in Computer Science series. All
participants in IFL 2012 are invited to submit either a draft paper or
an extended abstract describing work to be presented at the
symposium. Work submitted to IFL must not be submitted simultaneously
to other venues; submissions must adhere to ACM SIGPLAN's
republication policy: http://www.sigplan.org/republicationpolicy.htm.

The submissions will be screened by the program committee chair to
make sure they are within the scope of IFL, and will appear in the
draft proceedings distributed at the symposium. Submissions appearing
in the draft proceedings are not peer-reviewed publications. After the
symposium, authors will be given the opportunity to incorporate the
feedback from discussions at the symposium and will be invited to
submit a revised full article for the formal review process. From the
revised submissions, the program committee will select papers for the
formal proceedings considering their correctness, novelty,
originality, relevance, significance, and clarity.

Topics
--

IFL welcomes submissions describing practical and theoretical work as
well as submissions describing applications and tools. If you are not
sure that your work is appropriate for IFL 2012, please contact the PC
chair at ralf.hi...@cs.ox.ac.uk. Topics of interest include, but are
not limited to:

  language concepts
  type checking
  contracts
  compilation techniques
  staged compilation
  run-time function specialization
  run-time code generation
  partial evaluation
  (abstract) interpretation
  generic programming
  automatic program generation
  array processing
  concurrent/parallel programming
  concurrent/parallel program execution
  functional programming and embedded systems
  functional programming and web applications
  functional programming and security
  novel memory management techniques
  run-time profiling and performance measurements
  debugging and tracing
  virtual/abstract machine architectures
  validation and verification of functional programs
  tools and programming techniques
  (industrial) applications of functional programming

Submission details
--

Presentation submission deadline:   July 30th, 2012
Notification of acceptance: August 1st, 2012
Early registration deadline:August 10th, 2012
IFL 2012 Symposium: August 30-September 1, 2012
Submission for (post) review process:   November 30th, 2012
Notification Accept/Reject: February 4th, 2013
Camera ready version:   March 18th, 2013

Prospective authors are encouraged to submit papers or extended
abstracts to be published in the draft proceedings and to present them
at the symposium. All contributions must be written in English,
conform to the Springer-Verlag LNCS series format and not exceed 16
pages. The draft proceedings will appear as a technical report of the
Department of Computer Science of the University of Oxford.

(We are more liberal with the draft proceedings, where longer papers
or SIGPLAN 2 column 12 page papers are acceptable. For other formats
please contact the chair at ralf.hi...@cs.ox.ac.uk. For consideration
for the final proceedings, only the 16 page LNCS

[clean-list] Fwd: [Fp-nl] Dutch national FP day, January 6, Utrecht

2011-12-19 Thread Pieter Koopman




 Original Message 
Subject:[Fp-nl] Dutch national FP day, January 6, Utrecht
Date:   Fri, 16 Dec 2011 15:25:07 +0100
From:   S D Swierstra doai...@uu.nl
To: fp-nl fp...@cs.uu.nl
CC: Haskell Café List haskell-c...@haskell.org



On

http://www.cs.uu.nl/wiki/bin/view/FPDag2012/WebHome


you will find the program and registration  information about the next Dutch 
National Functional Programming day, on January 6, Utrecht University.

Please forward this mail to anyone interested.

Any questions can be directed to me.

 Hoping to meet you all,
 Doaitse Swierstra


___
Fp-nl mailing list
fp...@lists.science.uu.nl
http://lists.science.uu.nl/mailman/listinfo/fp-nl

___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] Data intensive programming and Clean

2011-12-16 Thread Pieter Koopman


Hi Chide,

For data-intensive programming it will be worthwhile to design your data 
structures carefully. This depends of course on your application.
The Clean compiler offers you unique arrays that might be pretty suited 
here. The uniqueness enforces restrictions on the way you write your 
algorithms. The benefit is that all updates will be done in-place, i.e. 
without creating garbage.
When you use an unboxed array the elements become strict, but access and 
storage is very efficient.


Below is an example of a program that creates matrix of the suggested 
size and applies a function to all its elements. My old laptop executes 
this in 0.25 s.


Have fun,

Pieter

:: *Matrix :== {#{#Int}}

matrix :: !Int !Int - Matrix
matrix n m = {{ j \\ j - [i..i+n-1]} \\ i - [0..m-1]}

mapMatrix :: (Int - Int) !Matrix - Matrix
mapMatrix f matrix = {{f e \\ e -: a} \\ a -: matrix}

test = (mapMatrix ((+) 7) myMatrix).[m-1].[n-1]
where
myMatrix = matrix n m
n = 30; m = 10

Start = test

On 15/12/2011 10:57 AM, Groenouwe, C. wrote:

I'm trying to find out:
- How, in general, functional programming languages perform on 
data-intensive tasks (manipulation of large datasets, e.g.: doing some 
statistical analysis on a table with 100.000 instances and 30 columns) 
(regarding speed and memory usage)

- Which functional language performs best?

A quick glance at the following benchmark, gave me the impression that 
Clean and Caml seem to perform best with regard to memory consumption:


http://shootout.alioth.debian.org/

Is that true?

Additional question: which functional languages exploits (hardware) 
parallelism running on a multi core CPU best? (Or more CPU's)?


Thanks in advance,

Chide





___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list
___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] distribution of 1 random number sequence throughout program

2011-11-11 Thread Pieter Koopman


Dear Chide,

Clean has a library for generating pseudo random numbers: 
MersenneTwister. As explained in the dcl file this produces pretty good 
random numbers based on an algorithm described in Mersenne Twister: A 
623-dimensionally equidistributed uniform pseudorandom number  
generator by M. Matsumoto and T. Nishimura in ACM Transactions on 
Modeling and Computer Simulation, vol. 8, no. 1, January 1998, pp. 3-30.


A simple way to distribute random numbers is the 'plumbing' approach of 
Burton and Page. If there is some state (like world or for IO) passed 
around you insert the list of numbers in the state and take as many 
values as you need. From your description I have the impression that 
this does not solve your problem.  It is possible to introduce such a 
state, but that can have a huge (and unwanted) impact on the structure 
of your program. It depends on your program if the plumbing approach 
will work well.


Spliting random stream in oven and odd values has a severe space leak 
penalty as Burton and Page point out. I used a scheme were random 
streams are split by starting a new stream with the current random 
number as seed:


split :: [Int] - ([Int],[Int])
split [a:x] = (genRandInt a, x)

This is somewhat similar to the random splitting of sequences as 
proposed by Burton and Page. For the Mersenne Twister the next random 
number is generally not related to a new sequence using the current 
number as seed.
For a program that uses a huge number of splits this can have a space 
penalty: each generator uses an array and all those arrays together can 
consume a significant amount of memory (depending on the number of 
splits and if they can be removed by the garbage collector or not).


If you do not want to have a state in your program for plumbing random 
numbers and need a huge number of splits, you can consider to use a 
simpler algorithm to generate pseudo random numbers. More specific: an 
algorithm that does not use much memory. For instance the algorithm used 
in Haskell as outlined in the Burton and Page paper.


So, unfortunately the final answer is 'it depends'. I am not aware of a 
library solving the problem for you.


Hope this helps,

Pieter

On 09/11/2011 11:22 PM, Groenouwe, C. wrote:

Dear Pieter (and others Clean specialists),

I tried to use random numbers in my clean program, however, I ran into 
the problem of distributing the pseudo random sequence to the 
different parts of my program. What is an elegant solution which 
doesn't restrict your program so much that it breaks possibilities for 
parallel computing etc. etc.? Doing some research I found this article:


http://www.cs.ou.edu/~rlpage/*Burton*PageRngJFP.pdf 
http://mailman.science.ru.nl/pipermail/clean-list/


and an old thread on the clean-list mailing list about this topic:

http://mailman.science.ru.nl/pipermail/clean-list/1995/22.html

which also turned out to refer to the mentioned article. My question 
is: which of the proposed methods in the thread and article do you 
recommend? Are there also libraries available to support the 
distribution?


Additional info: my program doesn't do much I/O, so I don't know 
whether piggy backing on the World parameter is an elegant solution 
(a suggestion I read in the old thread). Is the method of choice of 
Burton and Page also the best according to you (random splitting of a 
random sequence)?


TIA!

Chide
___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] Extended Deadline: CFP 2011 Symposium on Implementation and Application of Functional Languages

2011-08-22 Thread Pieter Koopman




The IFL deadline for submissions has been moved to the end of August. We already
have a great program scheduled (to be posted shortly), and hope to get a few 
more
interesting late additions because of this extension.

CALL FOR PAPERS

23rd Symposium on Implementation and
Application of Functional Languages (IFL 2011)
October 3-5, 2011
University of Kansas
Lawrence, Kansas, USA
http://www.ittc.ku.edu/ifl2011


The Symposium returns to the US this year, hosted by the University of Kansas,
in scenic Lawrence, Kansas. Lawrence is a lively college town less than an hour
from Kansas City and the Kansas City International Airport (MCI). The symposium
dates are October 3-5, 2011.

The goal of the IFL symposia is to bring together researchers actively engaged
in the implementation and application of functional and function-based
programming languages. IFL 2011 will be a venue for researchers to present and
discuss new ideas and concepts, work in progress, and publication-ripe results
related to the implementation and application of functional languages and
function-based programming.

Following the IFL tradition, IFL 2011 will use a post-symposium review process
to produce formal proceedings which will be published by Springer Verlag in the
Lecture Notes in Computer Science series. All participants in IFL 2011 are
invited to submit either a draft paper or an extended abstract describing work
to be presented at the symposium. At no time may work submitted to IFL be
simultaneously submitted to other venues. Here we follow the ACM Sigplan
republication policy: http://www.sigplan.org/republicationpolicy.htm.

The submissions will be screened by the program committee chair to make sure
they are within the scope of IFL, and will appear in the draft proceedings
distributed at the symposium. Submissions appearing in the draft proceedings
are not peer-reviewed publications. After the symposium, authors will be given
the opportunity to incorporate the feedback from discussions at the symposium
and will be invited to submit a revised full article for the formal review
process. These revised submissions will be reviewed by the program committee
using prevailing academic standards to select the best articles, which will
appear in the formal proceedings.

INVITED SPEAKER

Bryan O-Sullivan, author of Real World Haskell, and co-founder of
MailRank, Inc.

TOPICS

IFL welcomes submissions describing practical and theoretical work as well as
submissions describing applications and tools. If you are not sure that your
work is appropriate for IFL 2011, please contact the PC chair at
andyg...@ittc.ku.edu. Topics of interest include, but are not limited to:

 language concepts
 type checking
 contracts
 compilation techniques
 staged compilation
 runtime function specialization
 runtime code generation
 partial evaluation
 (abstract) interpretation
 generic programming techniques
 automatic program generation
 array processing
 concurrent/parallel programming
 concurrent/parallel program execution
 functional programming and embedded systems
 functional programming and web applications
 functional programming and security
 novel memory management techniques
 runtime profiling and performance measurements
 debugging and tracing
 virtual/abstract machine architectures
 validation and verification of functional programs
 tools and programming techniques
 industrial applications of functional programming

PAPER SUBMISSIONS

Prospective authors are encouraged to submit papers or extended abstracts to be
published in the draft proceedings and to present them at the symposium. All
contributions must be written in English, conform to the Springer-Verlag LNCS
series format and not exceed 16 pages. The draft proceedings will appear as a
technical report of the Department of Electrical Engineering and Computer
Science of the University of Kansas.

(We are more liberal with the draft proceedings, also accepting (for example)
longer papers or SIGPLAN 2 column 12 page papers. For other formats contact
the chair. For the consideration for the final proceedings, the 16 page
LNCS format is required.)

PETER LANDIN PRIZE

The Peter Landin Prize is awarded to the best paper presented at the symposium
every year. The honored article is selected by the program committee based on
the submissions received for the formal review process. The prize carries a
cash award equivalent to 150 Euros.

IMPORTANT DATES

Presentation submission deadline: (new) August 31st, 2011
Notification of acceptance:   (new) Within 24 hours of submission
Early registration deadline:  (new) September 16th, 2011
IFL 2011 Symposium: October 3-5, 2011
Submission for (post) review process:   November 30th, 2011
Notification Accept/Reject: January 30th, 2012
Camera ready version:   March 9th, 2012

PROGRAM COMMITTEE

Torben Amtoft, Kansas State University
Francesco Cesarini, Erlang Solutions Ltd
Olaf Chitil, University of Kent

[clean-list] CFP: 23rd Symposium on Implementation and Application of Functional Languages (IFL 2011)

2011-08-10 Thread Pieter Koopman

, University of Missouri
Ralf Hinze, Oxford University
James Hook, Portland State University
Garrin Kimmell, University of Iowa
Andres Löh, Well-Typed LLP
Rita Loogen, Philipps-University Marburg
Neil Mitchell, Standard Chartered
Rex Page, Oklahoma University
Rinus Plasmeijer, Radboud University Nijmegen
Sven-Bodo Scholz, University of Hertfordshire
Mary Sheeran, Chalmers
Satnam Singh, Microsoft Research
Walid Taha, Halmstad University
Simon Thompson, University of Kent
Geoffrey Washburn, LogicBlox


For information please contact:

Andy Gill, andyg...@ku.edu
Assistant Professor
The University of Kansas, EECS Department
Information and Telecommunication Technology Center
http://www.ittc.ku.edu/csdl/fpg/Users/AndyGill

Pieter Koopman

___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] How to show test result and change number of test

2011-04-13 Thread Pieter Koopman


Dear Lee Ho Yeung,

The current result indicates that no counterexamples are found.
In order to obtain a definition like f x = if ( x = 0) 1 (x*f(x-1) you 
need:

- a proper definition of the type Fun
- define or derive an instance of the generic functions for generation 
(ggen), equivalnece (gEq) en showing (genShow) element of the types 
used. Here you obviously need a special instance of genShow to obtain 
the indicate function.
- a definition of apply to turn elements of type Fun to the 
corresponding function.



The types I used are:
:: OR s t = L s | R t

:: BinOp x = OpPlus x x | OpTimes x x | OpMinus x x
:: Var = X
:: Expr = Expr (OR (OR Var IConst) (BinOp Expr))
:: FunAp = FunAp Int

:: RFun = RFun TermVal Expr (OR (OR Var IConst) (BinOp (OR (OR Var 
IConst) FunAp)))

:: Fun = Fun (OR Expr RFun)

:: TermVal = TermVal Int
:: IConst = IConst Int

The class apply looks like:

class apply d e v :: d - e - v

instance apply (OR x y) b c | apply x b c  apply y b c
where
apply (L x) = apply x
apply (R y) = apply y

instance apply (BinOp x) b v | apply x b v  +, -, * v
where
apply (OpPlus  x y) = \b.apply x b + apply y b
apply (OpMinus x y) = \b.apply x b - apply y b
apply (OpTimes x y) = \b.apply x b * apply y b

//  apply for ints 

instance apply IConst b Int where apply (IConst i) = \b.i
instance apply Var Int Int where apply X = \i.i
instance apply Var (x,Int) Int where apply X = \(_,i).i
instance apply Expr Int Int where apply (Expr f) = apply f
instance apply Expr (x,Int) Int where apply (Expr f) = \(_,i).apply f i
instance apply FunAp (Int-Int,Int) Int where apply (FunAp d) = \(f,i).f 
(i-d)

instance apply FunAp Int Int where apply (FunAp d) = abort FunAp Int Int
instance apply RFun Int Int
where apply rf=:(RFun (TermVal c) t e) = f
  where f i = if (i=c) (apply t i) (apply e (f,i))
instance apply Fun Int Int where apply (Fun f) = apply f

For data generation use something like:
ggen{|TermVal|} n r = map TermVal [0..5]
ggen{|FunAp|} n r = map FunAp [1..2]
ggen{|IConst|} n r = map IConst [0..8]
derive ggen OR, BinOp, Var, Expr, RFun, Fun

printing can be done like:

genShow{|OR|} fx fy sep p (L x)rest = fx sep p x rest
genShow{|OR|} fx fy sep p (R y)rest = fy sep p y rest
genShow{|IConst|}   sep p (IConst c)rest = [toString c:rest]
genShow{|BinOp|} fx sep p (OpPlus x y)rest = [if p ( : fx sep 
True x [+: fx sep True y [if p ) :rest]]]
genShow{|BinOp|} fx sep p (OpMinus x y)rest = [if p ( : fx sep 
True x [-: fx sep True y [if p ) :rest]]]
genShow{|BinOp|} fx sep p (OpTimes x y)rest = [if p ( : fx sep 
True x [*: fx sep True y [if p ) :rest]]]

genShow{|Var|}sep p vrest = [x:rest]
genShow{|Expr|}sep p (Expr e)rest = genShow{|*|} sep p e 
rest
genShow{|FunAp|}sep p (FunAp i)rest = [f (x-,toString 
i,):rest]

genShow{|TermVal|}  sep p (TermVal c)rest = [toString c:rest]
genShow{|RFun|}sep p (RFun c t e)rest
 = [if (x=:genShow{|*|} sep False c[) :genShow{|*|} sep True t [ 
: genShow{|*|} sep True e rest]]]
genShow{|Fun|}sep p (Fun f)rest = [f x = : 
genShow{|*|} sep False f rest]


Hopefully this helps.

Best regards,

Pieter Koopman

On 09/04/2011 12:00 PM, Lee Ho Yeung wrote:
when i try the following, it only show passed after 1000 test one case 
rejected and repeated with a few lines, but do not show f x = if ( x 
= 0) 1 (x*f(x-1)) as paper systematic synthesis of functions

which steps do i miss?
module martin001
import gast, StdEnv
prop1 :: Fun - Bool
prop1 d = ~(f 2 == 2  f 4 == 24  f 6 == 720) where f = apply d
Start = test prop1


___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list
___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] GRS vs LTRS

2009-06-17 Thread Pieter Koopman


Dear Vag,

Vag wrote:
To put in the nutshell, my point is that dag rewriting is better than 
graph rewriting as `base' of pure functional programming languages 
without manual proofs.

Better in the sense easier to reason about: I agree.
Better in the sense we do not need cycles: strongly disagree. There are 
algorithms that only have a reasonable complexity/efficiency due to a 
cycle. Without cycles we would need a more complex algorithm to mimic 
the effect. Cycles are nor used every day, but they do occur in real 
programs (not just Hamming numbers).


Consider a compiler that translates statements to machine instructions. 
This compilers yields the statements as well as the actual address for 
all labels used (in a tuple or record). These positions are feed to the 
compiler in order to generate the correct jumps. You can do this very 
elegantly with a cycle. If you cannot make this cycle you will probably 
need a two stage solution.


Best, Pieter
___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] Conf announcements on Clean-List

2009-06-08 Thread Pieter Koopman


Hi,

a long time ago there was a discussion about conference announcements on 
the Clean-list. The result was that the majority of people was 
interested in such announcements if they are on topic. The topic was 
defined rather broad as 'interesting for functional programmers in 
Clean'. As moderator I try to filter the messages according to that 
rule. If a large number of subscribers of this list wants to change 
that, I am happy to do so. Possible options:
a) messages on Clean and conferences possible of interest for people 
interested in Clean (the current situation)
b) messages on Clean and conferences calls with a narrow scope (e.g. 
Clean or 'functional programming' in the call)

c) only messages on Clean, no conference calls at all

Splitting the list in two where the moderator decides to which list a 
messages goes seems technically not that easy. However, there is the 
very low bandwidth Clean-announces.
Personally I have some mail filters on 'call for papers' and 'call for 
participation' etc and I apply these before the filter on 'Clean-list' 
this moves at least 90% of the calls from the Clean-List to the 
appropriate cfp mailbox. For me this is an excellent solution. The 
Clean-List is not diluted by the calls and I have the calls also 
available. Will this solve your problem Philip?


Best regards,

Pieter

Bernard van Gastel wrote:
Or maybe split the mailing list in two different ones: an announcement 
list for conferences/new clean versions/bugfixes and a different one 
for discussing Clean (the language and/or the naming of it).


With regards,
   Bernard

On Fri, Jun 5, 2009 at 10:36 PM, Philip Matthews 
philip_matth...@magma.ca mailto:philip_matth...@magma.ca wrote:


It seems these days that the vast majority of messages on the
Clean-List are conference announcements and the like, rather than
news and discussion of Clean. Since I am not interested in these
conference announcements, I am (regretfully) thinking of
unsubscribing. Before I do, I am just wondering if the mailing
list organizers have any plans to change the situation. (For
example, by requiring people to be subscribed in order to post,
and unsubscribing people who post such off-topic messages).

- Philip



___
clean-list mailing list
clean-list@science.ru.nl mailto:clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list




___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list
  

___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [clean-list] Yet another compiler crash

2008-09-18 Thread Pieter Koopman


Dear Vag,

Yes you found an error.
As a workaround: removing the strictness annotation (!) removes the problem.
You can also remove the record and write:
:: *T a = T !a

Best, Pieter

Vag wrote:

Help!

Especially frustrating compiler crash without any messages or ever 
black screens:


module cc
Start = 42
:: *S a = { sT :: !*(S a) }
add t = { sT = t }

mailto:clean-list@science.ru.nl
Changing options does not helps.





___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list
  

___
clean-list mailing list
clean-list@science.ru.nl
http://mailman.science.ru.nl/mailman/listinfo/clean-list

[clean-list] IFL23 - Deadline extension - Symposium on Implementation and Application of Functional Languages

[clean-list] IFL23 first CFP

[clean-list] IFL22: Early registration deadline August 15th

[clean-list] 2nd CFP - IFL22 - The 34th Symposium on Implementation and Application of Functional Languages

[clean-list] CALL FOR PAPERS - IFL22 - The 34th Symposium on Implementation and Application of Functional Languages

[clean-list] IFL'21 final call for participation

[clean-list] IFL'21 call for participation

[clean-list] IFL'21 Final call for papers

[clean-list] IFL'21 Third call for papers

[clean-list] IFL2021 second call for papers

[clean-list] IFL2021 First call for papers

[clean-list] CfP for TFPIE 19

[clean-list] Fwd: [TFP-AC] EAPLS Best PhD Award 2014

Re: [clean-list] hd (drop 1000000 [1..]) heapFull

Re: [clean-list] Is there a REPL??

Re: [clean-list] Memoization of recursive functions using Clean arrays

Re: [clean-list] Memoization of recursive functions using Clean arrays

Re: [clean-list] Memoization of recursive functions using Clean arrays

[clean-list] IFL2012: call for papers

[clean-list] Fwd: [Fp-nl] Dutch national FP day, January 6, Utrecht

Re: [clean-list] Data intensive programming and Clean

Re: [clean-list] distribution of 1 random number sequence throughout program

[clean-list] Extended Deadline: CFP 2011 Symposium on Implementation and Application of Functional Languages

[clean-list] CFP: 23rd Symposium on Implementation and Application of Functional Languages (IFL 2011)

Re: [clean-list] How to show test result and change number of test

Re: [clean-list] GRS vs LTRS

Re: [clean-list] Conf announcements on Clean-List

Re: [clean-list] Yet another compiler crash

28 matches

Site Navigation

Mail list logo

Footer information