Nabble - Clean

Re: observers in your plans?

2009-12-01T03:23:31Z

Hi Carlos,

As John showed, Clean's implementation of #! gives you what you need for this example, but is not as powerful as observer types. To make things work, Clean severely restricts the types of the variables that you can assign to (basically, they must be primitive types). Observer types are a lot more general, but whether or not this extra generality is worth the additional complexity of the type system I'm not sure.

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

FLoC 2010: Call for Papers

2009-11-30T09:19:07Z

2010 FEDERATED LOGIC CONFERENCE (FLoC'10)

Edinburgh, Scotland, U.K.
July 9-21, 2010
http://www.floc-conference.org

CALL FOR PAPERS

* The fifth Federated Logic Conference (FLoC'10) will be held in
Edinburgh, Scotland, U.K. (www.edinburgh.org), in July 2010, at the
School of Informatics at University of Edinburgh (www.inf.ed.ac.uk).

* The following conferences will participate in FLoC:
- CAV 2010: Int'l Conference on Computer-Aided Verification
- CSF 2010: IEEE Computer Security Foundations Symposium
- ICLP 2010: Int'l Conference on Logic Programming
- IJCAR 2010: Int'l Joint Conference on Automated Reasoning
- ITP 2010: Int'l Conference on Interactive Theorem Proving
- LICS 2010: IEEE Symposium on Logic in Computer Science
- RTA 2010: Int'l Conference on Rewriting Techniques and Applications
- SAT 2010: Int'l Conference on Theory and Applications of
Satisfiability Testing

* Plenary events involving all the conferences are planned. In addition
to the participating conferences, FLoC'10 will host a number of
pre- and post-conference workshops. There will be receptions in the
Edinburgh Castle and at the National Galleries of Scotland.

* Travel support for US student participants is expected.

* Detailed calls for papers (as well as submission instructions) for each
of the participating conferences can be found at the FLoC'10 website at
http://www.floc-conference.org

* Important dates:
- CAV 2010:
PC chairs: Byron Cook, Paul Jackson, Tayssir Touili
Jan 11: abstract submission deadline
Jan 15: paper submission deadline
- CSF 2010:
PC chairs: Michael Backes, Andrew Myers
Feb 04: abstract submission deadline
Feb 08: paper submission deadline
- ICLP 2010:
PC chairs: Manuel Hermenegildo, Torsten Schaub
Jan 26: paper registration deadline
Feb 02: paper submission deadline
- IJCAR 2010:
PC chairs: Jürgen Giesl, Reiner Hähnle
Jan 15: abstract submission deadline
Jan 22: paper submission deadline
- ITP 2010:
PC chairs: Matt Kaufmann, Lawrence C. Paulson
Jan 15: abstract submission deadline
Jan 22: paper submission deadline
- LICS 2010:
PC chair: Jean-Pierre Jouannaud
Jan 10: abstract submission deadline
Jan 17: paper submission deadline
- RTA 2010:
PC chair: Christopher Lynch
Jan 15: abstract submission deadline
Jan 22: paper submission deadline
- SAT 2010:
PC chairs: Ofer Strichman, Stefan Szeider
Feb 01: abstract submission deadline
Feb 08: paper submission deadline

* FLoC'10 Steering Committee:
- General Chair: Moshe Y. Vardi
- Conference Co-chairs: Leonid Libkin, Gordon Plotkin
- CAV Representative: Edmund Clarke
- ICLP Representative: Manuel Hermenegildo
- IJCAR Representative: Alan Bundy
- ITP Representative: Tobias Nipkow
- LICS Representative: Martin Abadi
- RTA Representative: Juergen Giesl
- SAT Representative: Enrico Giunchiglia
- EasyChair Representative: Andrei Voronkov

----------------------
You are subscribed to the FLoC 2010 mailing list.
To unsubscribe please send an email to majordomo@...
with the keywords unsubscribe floc2010 in the message body.
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: stuck with uniqueness in records

2009-11-29T07:56:41Z

Thanks John,

With the change you suggested it works.

This is how it looks now...

----------------- UMatrix.icl --------------------------------
implementation module UMatrix

import StdArray, StdInt, StdBool, StdMisc, StdList, StdEnum

::UMatrix elemType = { rows :: !Int
, cols :: !Int
, vals :: .({#} elemType)
}

make :: .Int .Int elemType -> .(UMatrix elemType) | Array {#} elemType
make n m v
| n > 0 && m > 0 = { rows = n
, cols = m
, vals = createArray (n*m) v
}
= abort "invalid matrix dimension"

// creates a matrix given an array of values
makeFrom :: .Int .Int u:{#a} -> v:(UMatrix a) | Array {#} a, [u <= v]
makeFrom n m arr
| n * m == size arr = { rows = n
, cols = m
, vals = arr
}
= abort "invalid UMatrix creation"

// exports values from a matrix as array
extract :: u:(UMatrix elemType) -> v:({#} elemType) | Array {#} elemType, [u <= v]
extract m = m.vals

// adds two matrices and produces a new one
add :: .(UMatrix elemType) (UMatrix elemType) -> .(UMatrix elemType) | Array {#} elemType & Arith elemType
add m1 m2
| sameSize m1 m2 = { rows = m1.rows
, cols = m1.cols
, vals = resp
}
= abort "Invalid matrix add"
where
l = (size (m2.vals)) - 1
base = createArray l m2.vals.[0]
resp = {base & [i] = m1.vals.[i] + m2.vals.[i] \\ i <- [0 .. l] }

// adds one matrix onto another (in place add)
fAdd :: *(UMatrix elemType) (UMatrix elemType) -> *(UMatrix elemType) | Array {#} elemType & Arith elemType
fAdd m1 m2
| sameSize m1 m2 = {m1 & vals = updateInPlace m1.vals f (size m2.vals)}
= abort "Invalid matrix add"
where
f v p = v + m2.vals.[p]

// --- internal

// true if same size
sameSize :: .(UMatrix e) .(UMatrix e) -> Bool
sameSize m1 m2
| not (m1.rows == m2.rows) = False
| not (m1.cols == m2.cols) = False
= True

// updates array first parameter with a function taking its value at p and p itself
updateInPlace :: *(a e) (e Int -> e) Int -> *(a e) | Array a e
updateInPlace arr1 f maxPos = updateLoop_ arr1 f 0 maxPos
where
updateLoop_ :: *(a e) (e Int -> e) Int Int -> *(a e) | Array a e
updateLoop_ arr1 f pos maxPos
| pos == maxPos = arr1
# (v, arr1) = arr1![pos]
= {(updateLoop_ arr1 f (pos+1) maxPos) & [pos] = f v pos}
------------------------------------------------------------------

The type of "extract" (*) - which I think should be a reasonable function to have in the API of such a module - now explains to me why the m1.vals works as first parameter in updateInPlace within fAdd : if m1.vals is used in a unique parameter (as in there), then m1 must be unique, which it is.
(*) more precisely, the coercion, the term used in Clean to refer to [u<=v]

Thanks a lot, kind of getting there.

regards
Carlos

----- Original Message ----
From: John van Groningen <johnvg@...>
To: Carlos Aya <carlosayam@...>
Cc: clean-list@...
Sent: Sat, 28 November, 2009 12:49:14 AM
Subject: Re: [clean-list] stuck with uniqueness in records

Carlos Aya wrote:

>..
>::UMatrix elemType = { rows :: !Int
> , cols :: !Int
> , vals :: ({#} elemType)
> }
>..
>The problem I am facing is update in place of the array vals, I want to have the following function (from implementation)
>
>...........................
>// adds one matrix onto another (in place add)
>fAdd :: *(UMatrix elemType) (UMatrix elemType) -> *(UMatrix elemType) | Array {#} elemType & Arith elemType
>fAdd m1 m2
>| sameSize m1 m2
> # (arr, m1) = m1!vals // <--- PROBLEM HERE
> = {m1 & vals = updateInPlace arr f (size m2.vals)}
>= abort "Invalid matrix add"
>where
> f v p = v + m2.vals.[p]
>..
>
>The problem is that updateInPlace expects a unique array, but the signature I am getting in PROBLEM HERE is
>
>m1!vals :: ({#a}, u:(UMatrix v:a))
>
>i.e., the array inside the record is not unique (at least, this is how I understand it).
>
>I have tried to define UMatrix with . and attribute variables in the hope that it will change the signature of the record "!" operator, but with no luck. And read the manual and the clean book but nothing said in b&w about the "!" operator, at least for me as I couldn't link the whole concept of uniqueness propagation for records.
>
>How can I extract the array from the unique parameter in fAdd and expect it to be unique?

Add a . before the array type in the declaration of type UMatrix:

::UMatrix elemType = { rows :: !Int
, cols :: !Int
, vals :: . {#elemType}
}

this makes the array unique if the record is unique,

and do not try to use ! to extract unique elements. This doesn't work
because of a limitation in the reference analysis. Instead extract
the element using a pattern match or a selection with .

Kind regards,

John van Groningen

__________________________________________________________________________________
Last chance to win a Sony entertainment pack thanks to Yahoo!7. Hurry, ends Nov 30. Enter now: http://au.docs.yahoo.com/homepageset/

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

Re: observers in your plans?

2009-11-29T06:51:22Z

Thanks John for pointing this.

I read that section but seemed too obscure to me initially...

regards
Carlos

----- Original Message ----
From: John van Groningen <johnvg@...>
To: Carlos Aya <carlosayam@...>
Cc: clean-list@...
Sent: Sat, 28 November, 2009 12:59:16 AM
Subject: Re: [clean-list] observers in your plans?

Carlos Aya wrote:

>Just curious if you have among the plans, implementation of so-called observer types, i.e. variables that do not add as counting occurences.

Clean already observer references, see section 9.4 of the reference manual.

For example, size can be used in a guard or in a #! as an observer.

>The problem with the following function ...
>
>doIt :: *(a e) (Int -> e) -> *(a e) | Array a e
>doIt arr f = {arr & [i] = f i \\ i <- [0.. (size arr)]}
>
>... is that (size arr) counts as occurrence in the body of doIt, so arr cannot be unique. But as seen in the _SystemArray implementation, size only reads the size of the array which we know is fixed. So, truly its signature should be
>
>size :: 0:arr -> Int
>
>(I put 0: to indicate an "observed" parameter, out of my ignorance.. and based on Odersky paper...)

This should work:

doIt arr f
#! s = size arr
= {arr & [i] = f i \\ i <- [0.. s-1]}

or you could use usize instead:

doIt arr f
# (s,arr) = usize arr
= {arr & [i] = f i \\ i <- [0.. s-1]}

Kind regards,

John van Groningen

__________________________________________________________________________________
Win 1 of 4 Sony home entertainment packs thanks to Yahoo!7.
Enter now: http://au.docs.yahoo.com/homepageset/

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

POPL 2010 - Call for participation

2009-11-28T07:37:02Z

*********************************************************************
* ACM SIGPLAN-SIGACT Symposium *
* on *
* Principles of Programming Languages *
* *
* January 20-22, 2010 *
* Madrid, Spain *
* *
* Call for Participation *
* *
* http://www.cse.psu.edu/popl/10/ *
*********************************************************************

Important dates

* Early registration deadline: December 22, 2009
* Hotel reservation deadline: December 28, 2009
* Conference: January 20-22, 2010

Hotel

All the conference events will take place at the Melia Castilla
Hotel, Madrid. We encourage attendees to stay at the conference
hotel. Information about the hotel can be found on the POPL web
page: http://www.cse.psu.edu/popl/10/

Scope

The annual Symposium on Principles of Programming Languages is a
forum for the discussion of fundamental principles and important
innovations in the design, definition, analysis, transformation,
implementation and verification of programming languages,
programming systems, and programming abstractions. Both
experimental and theoretical papers are welcome.

Preliminary program

A preliminary program can be found at the end of this email in text
format, or it can be found here:

http://www.cse.psu.edu/popl/10/program.html

Invited speakers

* Neil Gershenfeld (MIT, USA)
* Thomas A. Henzinger (IST, Austria)

Student Attendees

Students with accepted papers or posters are encouraged to apply for
a SIGPLAN PAC grant that will help to cover travel expenses to POPL.
Details on the PAC program and the application can be found in the
conference web site. PAC also offers support for companion travel.

General Chair:
Manuel Hermenegildo
Director, IMDEA Software Institute
Professor, C.S. Department, T.U. of Madrid (UPM), Spain

Program Chair:
Jens Palsberg
Professor, UCLA Computer Science Department

Program Committee:
Alex Aiken Stanford University
Rajeev Alur University of Pennsylvania
Cristiano Calcagno Imperial College, London
Juan Chen Microsoft Research
Wei-Ngan Chin National University of Singapore
Mads Dam Royal Institute of Technology, Stockholm
Erik Ernst Aarhus University
John Field IBM T. J. Watson Research Center
Cormac Flanagan UC Santa Cruz
Roberto Giacobazzi Universita' degli Studi di Verona
Rachid Guerraoui EPFL
Sorin Lerner UC San Diego
Calvin Lin University of Texas, Austin
Atsushi Ohori Tohoku University
Jens Palsberg UCLA
Andrey Rybalchenko Max Planck Institute for Software Systems
Amr Sabry Indiana University
Mooly Sagiv Tel-Aviv University
Peter Sewell University of Cambridge
Tayssir Touili CNRS-LIAFA

Affiliated Events

* WFLP: Functional and (Constraint) Logic Programming
* January 17, 2010

* VMCAI: Verification Model Checking and Abstract Interpretation
* January 17-19, 2010

* PADL: Practical Applications of Declarative Languages
* January 18-19, 2010

* DAMP: Declarative Aspects of Multicore Programming
* January 19, 2010

* PLPV: Programming Languages meets Program Verification
* January 19, 2010

* PEPM: Partial Evaluation and Semantics-Based Program Manipulation
* January 18-19, 2010

* TLDI:Types in Language Design and Implementation
* January 23, 2010

POPL 2010 Preliminary Program
-----------------------------

Wednesday, January 20, 2009
===========================

* Invited talk, 9:00-10:00
* Session Chair: Jens Palsberg (UCLA)
- Reconfigurable Asynchronous Logic Automata
Neil Gershenfeld (MIT, USA)

* Session: Concurrency, 10:30-11:30
* Session Chair: John Field (IBM T. J. Watson Research Center)
- On the Verification Problem for Weak Memory Models
Mohamed Faouzi Atig (LIAFA, University Paris Diderot),
Ahmed Bouajjani (LIAFA, University Paris Diderot),
Sebastian Burckhardt (Microsoft Research),
Madan Musuvathi (Microsoft Research)
- Coarse-Grained Transactions
Eric Koskinen (University of Cambridge), Matthew Parkinson
(University of Cambridge), Maurice Herlihy (Brown University)
- Sequential Verification of Serializability
H. Attiya (Technion), G. Ramalingam (Microsoft Research India),
N. Rinetzky (Queen Mary University of London)

* Session: Static Analysis I, 12:00-1:00
* Session Chair: Tayssir Touili (CNRS-LIAFA)
- Compositional May-Must Program Analysis: Unleashing the Power of
Alternation
Patrice Godefroid (Microsoft Research Redmond),
Aditya V. Nori (Microsoft Research India),
Sriram K. Rajamani (Microsoft Research India),
Sai Deep Tetali (Microsoft Research India)
- Continuity Analysis of Programs
Authors: Swarat Chaudhuri (Pennsylvania State University),
Sumit Gulwani (Microsoft Research),
Roberto Lublinerman (Pennsylvania State University)
- Program Analysis via Satisfiability Modulo Path Programs
William R. Harris (University of Wisconsin, Madison, WI),
Sriram Sankaranarayanan (NEC Laboratories America, Princeton, NJ),
Franjo Ivancic (NEC Laboratories America, Princeton, NJ),
Aarti Gupta (NEC Laboratories America, Princeton, NJ)

* Session: Verified Compilers, 2:30-3:30
* Session Chair: Sorin Lerner (UC San Diego)
- A simple, verified validator for software pipelining
Jean-Baptiste Tristan (INRIA Paris-Rocquencourt),
Xavier Leroy (INRIA Paris-Rocquencourt)
- A Verified Compiler for an Impure Functional Language
Adam Chlipala (Harvard University)
- Verified just-in-time compiler on x86
Magnus O. Myreen (University of Cambridge)

* Session: Type Inference, 4:00-5:00
* Session Chair: Benjamin Pierce (University of Pennsylvania)
- Dependent Types from Counterexamples
Tachio Terauchi (Tohoku University)
- Low-Level Liquid Types
Patrick Rondon (UC San Diego), Ranjit Jhala (UC San Diego),
Ming Kawaguchi (UC San Diego)
- Type Inference for Datalog with Complex Type Hierarchies
Max Schaefer (Semmle Ltd., Oxford), Oege de Moor (Semmle Ltd., Oxford)

Thursday, January 21, 2009
==========================

* Invited talk, 9:00-10:00
* Session Chair: Jens Palsberg (UCLA)
- From Boolean to Quantitative Notions of Correctness
Thomas A. Henzinger (IST, Austria)

* Session: Reasoning about Programs, 10:30-11:30
* Session Chair: Roberto Giacobazzi (Universita' degli Studi di Verona)
- Nominal System T
Andrew M. Pitts (University of Cambridge)
- A Theory of Indirection via Approximation
Aquinas Hobor (National University of Singapore),
Robert Dockins (Princeton University), Andrew W. Appel (Princeton University)
- A Relational Modal Logic for Higher-Order Stateful ADTs
Derek Dreyer (MPI-SWS), Georg Neis (MPI-SWS), Andreas Rossberg (MPI-SWS),
Lars Birkedal (ITU-Copenhagen)

* Session: Static Analysis II, 12:00-1:00
* Session Chair: Andrey Rybalchenko (Max Planck Institute for Software Systems)
- Decision Procedures for Algebraic Data Types with Abstractions
Philippe Suter (EPFL), Mirco Dotta (EPFL), Viktor Kuncak (EPFL)
- Automatic Numeric Abstractions for Heap-Manipulating Programs
Stephen Magill (Carnegie Mellon University),
Ming-Hsien Tsai (National Taiwan University),
Peter Lee (Carnegie Mellon University),
Yih-Kuen Tsay (National Taiwan University)
- Static Determination of Quantitative Resource Usage for Higher-Order
Programs
Steffen Jost (University of St Andrews),
Hans-Wolfgang Loidl (University of St Andrews),
Kevin Hammond (University of St Andrews),
Martin Hofmann (Ludwig-Maximilians University, Munich)

* Session: Verification, 2:30-3:30
* Session Chair: Xavier Leroy (INRIA Rocquencourt)
- Toward a Verified Relational Database Management System
Ryan Wisnesky (Harvard University), Gregory Malecha (Harvard University),
Avraham Shinnar (Harvard University), Greg Morrisett (Harvard University)
- Counterexample-Guided Focus
Andreas Podelski (University of Freiburg), Thomas Wies (EPFL)
- Structuring the verification of heap-manipulating programs
Aleksandar Nanevski (Microsoft Research, Cambridge / IMDEA Software, Spain),
Viktor Vefeiadis (Microsoft Research, Cambridge),
Josh Berdine (Microsoft Research, Cambridge)

* Session: Types, 4:00-5:00
* Session Chair: Erik Ernst (Aarhus University)
- Dependent types and program equivalence
Limin Jia (University of Pennsylvania),
Jianzhou Zhao (University of Pennsylvania),
Vilhelm Sjoberg (University of Pennsylvania),
Stephanie Weirich (University of Pennsylvania)
- Pure Subtype Systems
DeLesley Hutchins (MZA Associates Corporation)
- Modular Session Types for Distributed Object-Oriented Programming
Simon J Gay (University of Glasgow, UK),
Vasco T Vasconcelos (University of Lisbon, Portugal),
Antonio Ravara (Instituto de Telecomunicacoes and Technical
University of Lisbon, Portugal),
Nils Gesbert (University of Glasgow, UK),
Alexandre Z Caldeira (University of Lisbon, Portugal)

Friday, January 22, 2009
=========================

* Session: Program Synthesis, 9:00-10:00
* Session Chair: Cristiano Calcagno (Imperial College, London)
- From Program Verification to Program Synthesis
Saurabh Srivastava (University of Maryland, College Park),
Sumit Gulwani (Microsoft Research, Redmond),
Jeffrey S. Foster (University of Maryland, College Park)
- Abstraction-Guided Synthesis of Synchronization
Martin Vechev (IBM Research), Eran Yahav (IBM Research),
Greta Yorsh (IBM Research)
- Programming with Angelic Non-determinism
Shaon Barman (UC Berkeley), Rastislav Bodik (UC Berkeley),
Satish Chandra (IBM TJ Watson Research), Joel Galenson (UC Berkeley),
Doug Kimelman (IBM TJ Watson Research), Casey Rodarmor (UC Berkeley),
Nicholas Tung (UC Berkeley)

* Session: Relating and Integrating Static and Dynamic Checks, 10:30-11:30
* Session Chair: Matthias Felleisen (Northeastern University)
- Contracts Made Manifest
Michael Greenberg (University of Pennsylvania),
Benjamin Pierce (University of Pennsylvania),
Stephanie Weirich (University of Pennsylvania)
- Threesomes, With and Without Blame
Jeremy G. Siek (University of Colorado at Boulder),
Philip Wadler (University of Edinburgh)
- Integrating Typed and Untyped Code in a Scripting Language
Tobias Wrigstad (Purdue University), Francesco Zappa Nardelli (INRIA),
Sylvain Lebresne (Purdue University), Johan Ostlund (Purdue University),
Jan Vitek (Purdue University)

* Session: Compilers, 12:00-1:00
* Session Chair: Peter Sewell (University of Cambridge)
- Generating Compiler Optimizations from Proofs
Ross Tate (UC San Diego), Michael Stepp (UC San Diego),
Sorin Lerner (UC San Diego)
- Automatically Generating Instruction Selectors Using Declarative
Machine Descriptions
Joao Dias (Tufts University), Norman Ramsey (Tufts University)
- Semantics and Algorithms for Data-dependent Grammars
Yitzhak Mandelbaum (AT&T Labs - Research), Trevor Jim (AT&T Labs - Research),
David Walker (Princeton University)

* Session: Security and Ownership, 2:30-3:30
* Session Chair: Mads Dam (Royal Institute of Technology, Stockholm)
- Paralocks - Role-Based Information Flow Control and Beyond
Niklas Broberg (Gothenburg University),
David Sands (Chalmers University of Technology)
- Modular Verification of Security Protocol Code by Typing
Karthikeyan Bhargavan (Microsoft Research),
Cedric Fournet (Microsoft Research),
Andrew D. Gordon (Microsoft Research)
- Dynamically Checking Ownership Policies in Concurrent C/C++ Programs
Jean-Phillipe Martin (Microsoft Research Cambridge),
Michael Hicks (University of Maryland, College Park),
Manuel Costa (Microsoft Research Cambridge),
Periklis Akritidis (University of Cambridge),
Miguel Castro (Microsoft Research Cambridge)

* Session: Medley, 4:00-5:00
* Session Chair: Mooly Sagiv (Tel-Aviv University)
- Nested Interpolants
Matthias Heizmann (University of Freiburg, Germany),
Jochen Hoenicke (University of Freiburg, Germany),
Andreas Podelski (University of Freiburg, Germany)
- Monads in Action
Andrzej Filinski (University of Copenhagen)
- Higher-Order Multi-Parameter Tree Transducers and Recursion Schemes
for Program Verification
Naoki Kobayashi (Tohoku University), Naoshi Tabuchi (Tohoku University),
Hiroshi Unno (Tohoku University)

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

Re: observers in your plans?

2009-11-27T05:59:16Z

Carlos Aya wrote:

>Just curious if you have among the plans, implementation of so-called observer types, i.e. variables that do not add as counting occurences.

Clean already observer references, see section 9.4 of the reference manual.

For example, size can be used in a guard or in a #! as an observer.

This should work:

doIt arr f
#! s = size arr
= {arr & [i] = f i \\ i <- [0.. s-1]}

or you could use usize instead:

doIt arr f
# (s,arr) = usize arr
= {arr & [i] = f i \\ i <- [0.. s-1]}

Kind regards,

John van Groningen
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: stuck with uniqueness in records

2009-11-27T05:49:14Z

Carlos Aya wrote:

Add a . before the array type in the declaration of type UMatrix:

::UMatrix elemType = { rows :: !Int
, cols :: !Int
, vals :: . {#elemType}
}

this makes the array unique if the record is unique,

and do not try to use ! to extract unique elements. This doesn't work
because of a limitation in the reference analysis. Instead extract
the element using a pattern match or a selection with .

Kind regards,

John van Groningen
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

observers in your plans?

2009-11-27T01:53:42Z

Dear Clean Team,

Just curious if you have among the plans, implementation of so-called observer types, i.e. variables that do not add as counting occurences.

The problem with the following function ...

doIt :: *(a e) (Int -> e) -> *(a e) | Array a e
doIt arr f = {arr & [i] = f i \\ i <- [0.. (size arr)]}

... is that (size arr) counts as occurrence in the body of doIt, so arr cannot be unique. But as seen in the _SystemArray implementation, size only reads the size of the array which we know is fixed. So, truly its signature should be

size :: 0:arr -> Int

(I put 0: to indicate an "observed" parameter, out of my ignorance.. and based on Odersky paper...)

So, although doIt as idea doesn't conflict with update-in-place, it cannot be implemented in Clean.

What do you think?

Kind regards
Carlos

__________________________________________________________________________________
Win 1 of 4 Sony home entertainment packs thanks to Yahoo!7.
Enter now: http://au.docs.yahoo.com/homepageset/

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

stuck with uniqueness in records

2009-11-27T01:35:39Z

Dear All,

Continuing with array update, now I want to wrap the array into a record. Basically to convert it into a 2D matrix. I want to put it into an abstract type, like

---- UMatrix.dcl ------
definition module UMatrix

import StdArray, StdClass

// UMatrix : Unboxed matrix, elemType must be one of the available unboxed types
::UMatrix elemType | Array {#} elemType

// ... more stuff ...

---------------------------

with the following implementation module:

---- UMatrix.icl ------
implementation module UMatrix

import StdArray, StdInt, StdBool, StdMisc, StdList, StdEnum

::UMatrix elemType = { rows :: !Int
, cols :: !Int
, vals :: ({#} elemType)
}

// ... more stuff ...

---------------------------

The problem I am facing is update in place of the array vals, I want to have the following function (from implementation)

...........................
// adds one matrix onto another (in place add)
fAdd :: *(UMatrix elemType) (UMatrix elemType) -> *(UMatrix elemType) | Array {#} elemType & Arith elemType
fAdd m1 m2
| sameSize m1 m2
# (arr, m1) = m1!vals // <--- PROBLEM HERE
= {m1 & vals = updateInPlace arr f (size m2.vals)}
= abort "Invalid matrix add"
where
f v p = v + m2.vals.[p]

// ...
// .. where updateInPlace is the array update in-place which I put together with your help before. ...
// ...

// updates array first parameter with a function taking its value at p and p itself
updateInPlace :: *(a e) (e Int -> e) Int -> *(a e) | Array a e
updateInPlace arr1 f maxPos = updateLoop_ arr1 f 0 maxPos
where
updateLoop_ :: *(a e) (e Int -> e) Int Int -> *(a e) | Array a e
updateLoop_ arr1 f pos maxPos
| pos == maxPos = arr1
# (v, arr1) = arr1![pos]
= {(updateLoop_ arr1 f (pos+1) maxPos) & [pos] = f v pos}
............................

The problem is that updateInPlace expects a unique array, but the signature I am getting in PROBLEM HERE is

m1!vals :: ({#a}, u:(UMatrix v:a))

i.e., the array inside the record is not unique (at least, this is how I understand it).

I have tried to define UMatrix with . and attribute variables in the hope that it will change the signature of the record "!" operator, but with no luck. And read the manual and the clean book but nothing said in b&w about the "!" operator, at least for me as I couldn't link the whole concept of uniqueness propagation for records.

How can I extract the array from the unique parameter in fAdd and expect it to be unique?

Thanks in advance

Carlos

__________________________________________________________________________________
Last chance to win a Sony entertainment pack thanks to Yahoo!7. Hurry, ends Nov 30. Enter now: http://au.docs.yahoo.com/homepageset/

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

IJCAR 2010 - first call for papers

2009-11-25T15:05:57Z

IJCAR 2010 - The 5th International Joint Conference on Automated Reasoning
Edinburgh, UK, July 16-19, 2010

as part of FLoC 2010 - Federated Logic Conference

http://www.floc-conference.org/

Call for Papers
---------------

IJCAR is the premier international joint conference on all topics
in automated reasoning. The IJCAR technical program will consist
of presentations of high-quality original research papers,
system descriptions, and invited talks.

IJCAR 2010 is a merger of leading events in automated reasoning:

CADE (Conference on Automated Deduction),
FroCoS (Workshop on Frontiers of Combining Systems),
FTP (Workshop on First-order Theorem Proving), and
TABLEAUX (Conference on Analytic Tableaux and Related Methods)

IJCAR 2010 invites submissions related to all aspects of automated
reasoning, including foundations, implementations, and applications.
Original research papers and descriptions of working automated deduction
systems are solicited.

The proceedings of IJCAR 2010 will be published by Springer-Verlag in
the LNAI/LNCS series.

Submission details: Submission is electronic, through

https://www.easychair.org/login.cgi?conf=ijcar2010

Authors are strongly encouraged to use LaTeX and the Springer "llncs"
format, which can be obtained from
http://www.springer.de/comp/lncs/authors.html.
The page limit is 15 pages for full papers, and 7 pages for system
descriptions.

Program co-chairs:
Juergen Giesl (RWTH Aachen University, Germany)
Reiner Haehnle (Chalmers University of Technology, Sweden)

Conference chair:
Alan Bundy (University of Edinburgh, UK)

Workshop chair:
Aaron Stump (University of Iowa, USA)

Publicity chair:
Viorica Sofronie-Stokkermans (MPI-INF Saarbruecken, Germany)

Important dates:
Abstract submission deadline: January 15, 2010
Paper submission deadline: January 22, 2010
Notification of paper decisions: March 15, 2010
Final version of papers due: April 19, 2010
Conference dates: July 16-19, 2010

Student Travel Awards:
Travel awards will be available to enable selected students to attend the
conference. Details will be published in March 2010.

Program Committee:
Carlos Areces (INRIA Nancy Grand Est, France)
Alessandro Armando (University of Genova, Italy)
Franz Baader (Technical University of Dresden, Germany)
Peter Baumgartner (NICTA Canberra, Australia)
Bernhard Beckert (University of Koblenz, Germany)
Christoph Benzmueller (International University Bruchsal, Germany)
Nikolaj Bjorner (Microsoft Research, USA)
Maria Paola Bonacina (Universita` degli Studi di Verona, Italy)
Alan Bundy (University of Edinburgh, UK)
Gilles Dowek (Ecole Polytechnique, France)
Christian Fermueller (Vienna University of Technology, Austria)
Ulrich Furbach (University of Koblenz, Germany)
Didier Galmiche (LORIA Nancy, France)
Silvio Ghilardi (University of Milano, Italy)
Martin Giese (University of Oslo, Norway)
Juergen Giesl (RWTH Aachen University, Germany)
Rajeev Gore (The Australian National University, Australia)
Bernhard Gramlich (Vienna University of Technology, Austria)
Reiner Haehnle (Chalmers University of Technology, Sweden)
Ullrich Hustadt (University of Liverpool, UK)
Deepak Kapur (University of New Mexico, USA)
Viktor Kuncak (EPFL Lausanne, Switzerland)
Rustan Leino (Microsoft Research, USA)
Carsten Lutz (University of Bremen, Germany)
George Metcalfe (University of Bern, Switzerland)
Aart Middeldorp (University of Innsbruck, Austria)
Neil Murray (University at Albany - SUNY, USA)
Tobias Nipkow (Technical University of Munich, Germany)
Nicola Olivetti (LSIS, University of Aix-Marseille, France)
Nicolas Peltier (LIG Grenoble, France)
Frank Pfenning (Carnegie Mellon University, USA)
Brigitte Pientka (McGill University, Canada)
Andre Platzer (Carnegie Mellon University, USA)
Christophe Ringeissen (LORIA Nancy, France)
Albert Rubio (UPC Barcelona, Spain)
Renate Schmidt (The University of Manchester, UK)
Carsten Schuermann (IT University of Copenhagen, Denmark)
Roberto Sebastiani (University of Trento, Italy)
Viorica Sofronie-Stokkermans (MPI-INF Saarbruecken, Germany)
Aaron Stump (University of Iowa, USA)
Geoff Sutcliffe (University of Miami, USA)
Cesare Tinelli (University of Iowa, USA)
Ashish Tiwari (SRI International, USA)
Andrei Voronkov (The University of Manchester, UK)
Christoph Weidenbach (MPI-INF Saarbruecken, Germany)

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

Memocode 2010 First Call for Papers

2009-11-25T07:53:31Z

MEMOCODE 2010 First Call for Papers

The eighth ACM-IEEE International Conference on Formal Methods and
Models for Codesign (MEMOCODE 2010) will be held
on July 26-28, 2010 in Grenoble, France.

http://www.memocode-conference.com

----------------------------------------------------

IMPORTANT DATES:

Abstract submission deadline: February 26, 2010
Paper submission deadline: March 5, 2010
Notification of acceptance: April 30, 2010
Poster submission deadline: May 14, 2010
Notification for Posters: May 28, 2010
Final Version for Papers: May 28, 2010

----------------------------------------------------

The eighth MEMOCODE conference will attract researchers and
practitioners who create methods, tools, and architectures for the
design of hardware/software systems. These systems face increasing
design complexity including tighter constraints on timing, power, costs,
and reliability. MEMOCODE seeks submissions that present novel formal
methods and design techniques addressing these issues to create, refine,
and verify hardware/software systems. We also invite
application-oriented papers, and especially encourage submissions that
highlight the design perspective of formal methods and models, including
success stories and demonstrations of hardware/software codesign.
Furthermore, we invite poster presentations describing ongoing work with
promising preliminary results.

Topics of interest for regular submissions include but are not limited to
- system- and transaction-level modeling and verification, abstraction
and refinement between different modeling levels, formal, semi-formal,
and specification-driven verification,
- design and verification methods for composition of concurrent systems:
multi-core platform architectures, systems-on-chip, networks-on-chip,
- non-traditional and domain-specific design languages for hardware and
software, novel models of computation, and new design paradigms that
unify hardware and software design,
- system-level estimation of performance and power in heterogeneous
hardware/software architectures,
- applications and demonstrators of formal design methodologies and case
studies of innovative system-level design flows, and
- modeling and reuse of intellectual property at system-level.

PROCEEDINGS:

Conference proceedings will be published by the IEEE Computer Society.

SUBMISSION:

Submissions of research and experience papers will only be accepted
through the conference web site. Papers must not exceed 10 pages and
must be formatted following IEEE Computer Society guidelines.
Submissions must be written in English, describe original work, and not
substantially overlap papers that have been published or are being
submitted to a journal or another conference with published proceedings.
Poster submissions should consist of an abstract of at most 250 words.
The abstract will be distributed to the conference attendants but will
not be published. Note that the poster deadline is different from the
paper deadline.

DESIGN CONTEST:

MEMOCODE will again have a design contest. The contest will start March
1, 2010. The deadline for submission is 31 March 2010 and the
notification of the results is on May 14, 2010. The conference will
sponsor at least two prize categories, each with a significant cash
award. We awarded a $1000 prize in each of the two categories in 2009.
Each team that submits a complete and working entry will be invited to
submit for review a 2-page abstract for the formal conference
proceedings; winning teams will be invited to contribute a 4-page short
paper. Each team submitting a completed and working entry will also
receive a commemorative plaque with their name and results. Please refer
to the conference website for more information and updates.

TUTORIALS:

MEMOCODE will feature tutorials related to hardware/software codesign.
Please send your tutorial proposals to alain.girault@....

----------------------------------------------------

General Chair: Klaus Schneider (Kaiserslauten)
Finance Chair: James Hoe (CMU)
Program Chairs: Barbara Jobstmann (CNRS) and Luca Carloni (Columbia)
Design Contest: Joel Emer (Intel) and Forrest Brewer (UCSB)
Local Chairs: Saddek Bensalem (UJF/CEA) and Christian Fabre (CEA)
Tutorial Chair: Alain Girault (INRIA)

Program Committee

David Atienza (EPFL)
Twan Basten (Eindhoven)
Tevfik Bultan (UCSB)
Robert de Simone (INRIA)
Rainer Doemer (UCI)
Rolf Drechsler (Bremen)
Stephen Edwards (Columbia)
Franco Fummi (Verona)
Thierry Gautier (INRIA)
Ganesh Gopalakrishnan (Utah)
Josef Haid (Infineon)
Franjo Ivancic (NEC)
Christoph Kirsch (Salzburg)
Daniel Kroening (Oxford)
Yassine Lakhnech (UJF)
Luciano Lavagno (Torino)
Elizabeth Leonard (NRL)
Rishiyur Nikhil (Bluespec, Inc.)
John O'Leary (Intel)
Roberto Passerone (Trento)
Diego Puschini (CEA)
Jan Reineke (UC Berkeley)
Patrick Schaumont (VirginiaTech)
Klaus Schneider (Kaiserslautern)
Sanjit Seshia (UC Berkeley)
Natasha Sharygina (Lugano)
Satnam Singh (Microsoft)
Michael Theobald (DE Shaw)
Lothar Thiele (ETHZ)
Fei Xie (Portland State)

Steering Committee

Arvind (MIT)
Masahiro Fujita (University Tokyo)
Rajesh Gupta (UC San Diego)
Connie Heitmeyer (NRL)
James Hoe (CMU)
Sandeep Shukla (Virginia Tech)
Jean-Pierre Talpin (INRIA)

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

WGT 2010 Submission Deadline Extension and Final Call for Papers

2009-11-22T02:48:02Z

[ Apologies for multiple copies of this announcement ]

****************************************************************

FINAL CALL FOR PAPERS

Second Workshop on Generative Technologies
WGT 2010

http://wgt2010.elte.hu/

a satellite event of the
13th European Joint Conferences on
Theory and Practice of Software
(ETAPS 2010)
Paphos - Cyprus
March 27, 2010

****************************************************************

IMPORTANT DATES

- Submission of full paper: November 30, 2009
- Submission of tool demo paper: November 30, 2009
- Author notification: January 11, 2010
- Final version due: January 25, 2010

****************************************************************

SCOPE

Generative programming is an emerging paradigm aimed
at automating important tasks in software development,
compile-time and run-time code transformation, and the creation of
domain-specific languages and flexible libraries. The purpose of the
workshop is to provide a forum for researchers and practitioners working in
this area to discuss
state-of-the-art generative technologies and tools, and
exchange ideas about the future of generative programming.
Papers describing practical applications of generative styles,
and new research directions are expected. Suggested areas of
interest in the workshop include, but are not limited to:

- Generative programming, metaprogramming
- Separation of concerns
- Intentional programming
- Domain engineering and domain analysis
- Product-line architectures
- Feature-based techniques
- Compile-time and run-time code transformation
- Multi-stage languages
- Generic and Active library-development
- Analysis of language support for generative programming
- Semantics, type-systems of generative programs
- Case Studies and Demonstration Cases

****************************************************************

PAPER SUBMISSION

RESEARCH PAPERS (full papers, 8-10 pages) as well as TOOL DEMO PAPERS (up
to 2 pages) should be submitted to the WGT 2010 organizers in ENTCS format
(http://www.entcs.org). Submissions should be sent by e-mail to
wgt@....

Accepted workshop papers are published in the local proceedings. After
the workshop the participants are invited for submission to journal ENTCS
(only research papers). The workshop organizers have intention to set the
deadline of this second submission being later then the notification on
GPCE papers. Hence authors have opportunity to send their paper to GPCE
and if rejected, send to ENTCS without violating usual resubmission policy.

Further information will be available at the WGT 2010 home page.
At least one author of each accepted submission must register
and present the paper at the workshop.

****************************************************************

PROCEEDINGS

After revision, final copies of the accepted papers will be
published in Electronic Notes in Theoretical Computer Science
(ENTCS), Elsevier Science (http://www.entcs.org).

****************************************************************

PROGRAM COMMITTEE

- Don Batory University of Texas at Austin (USA)
- Jaakko Järvi Texas A&M University (USA)
- Julia Lawall University of Copenhagen (DK)
- Hanspeter Mössenböck Johannes Kepler University Linz (AT)
- Zoltán Porkoláb Eotvos Lorand University (HUN)
- Awais Rashid Lancaster University (UK)
- Joao Saraiva University of Minho (POR)
- Bran Selic Malina Software Corp (CAN)
- Yannis Smaragdakis University of Massachusetts, Amherst (USA)

****************************************************************

ORGANIZING COMMITTEE

- Zoltan Porkolab Eotvos Lorand University (HUN)
- Norbert Pataki Eotvos Lorand University (HUN)
- Zalan Szugyi Eotvos Lorand University (HUN)

e-mail: wgt@...

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

Re: definition and propagation of class constraints

2009-11-20T08:52:13Z

Carlos Aya wrote:

>I want to to this:
>------------------ umatrix.dcl ---------------------------------------------------------------------
>definition module UMatrix
>
>import StdArray
>// UMatrix : Unboxed matrix, elemType must be one of the available unboxed types
>::UMatrix elemType | Array {#} elemType
>..
>
>but I don't know (couldn't find) how to define the abstract type UMatrix in the definition module, annotated with corresponding class constraint.

Class constraints cannot be used in type definitions (synonym, algebraic,
record or abstract).

>..
>::UMatrix elemType = { rows :: Int
> , cols :: Int
> , vals :: {#} elemType
> }
>
>make :: .Int .Int elemType -> .(UMatrix elemType)
>make n m v
>| n > 0 && m > 0 = { rows = n
> , cols = m
> , vals = createArray (n*m) v
> }
>..
>therefore the compiler complains that "internal overloading of createArray" cannot be solved.
>
>My questions
>- if UMatrix e is annotated with Array {#} e, why do I need to especify that in make if e appears in the return type? Isn't this inferred?

You cannot annotate UMatrix e with Array {#} e, therefore you have to
add the context Array {#} e at the end of the type of make.

Kind regards,

John van Groningen
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: [Haskell] ANNOUNCE: Haskell Communities and Activities Report (17th ed., November 2009)

2009-11-20T05:39:36Z

Brilliant. Thank you Janis!

|
| On behalf of the many, many contributors, I am pleased to announce
| that the
|
| Haskell Communities and Activities Report
| (17th edition, November 2009)
|
| http://www.haskell.org/communities/
|
| is now available from the Haskell Communities home page in PDF and
| HTML formats.

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

ANNOUNCE: Haskell Communities and Activities Report (17th ed., November 2009)

2009-11-20T04:17:59Z

On behalf of the many, many contributors, I am pleased to announce
that the

Haskell Communities and Activities Report
(17th edition, November 2009)

http://www.haskell.org/communities/

is now available from the Haskell Communities home page in PDF and
HTML formats.

Many thanks go to all the people that contributed to this report,
both directly, by sending in descriptions, and indirectly, by doing
all the interesting things that are reported. I hope you will find
it as interesting a read as I did.

If you have not encountered the Haskell Communities and Activities
Reports before, you may like to know that the first of these reports
was published in November 2001. Their goal is to improve the
communication between the increasingly diverse groups, projects, and
individuals working on, with, or inspired by Haskell. The idea behind
these reports is simple:

Every six months, a call goes out to all of you enjoying Haskell to
contribute brief summaries of your own area of work. Many of you
respond (eagerly, unprompted, and sometimes in time for the actual
deadline ;-) to the call. The editor collects all the contributions
into a single report and feeds that back to the community.

When I try for the next update, six months from now, you might want
to report on your own work, project, research area or group as well.
So, please put the following into your diaries now:

----------------------------------------
End of April 2010:
target deadline for contributions to the
May 2010 edition of the HC&A Report
----------------------------------------

Unfortunately, many Haskellers working on interesting projects are so
busy with their work that they seem to have lost the time to follow
the Haskell related mailing lists and newsgroups, and have trouble even
finding time to report on their work. If you are a member, user or
friend of a project so burdened, please find someone willing to make
time to report and ask them to "register" with the editor for a simple
e-mail reminder in October (you could point me to them as well, and I
can then politely ask if they want to contribute, but it might work
better if you do the initial asking). Of course, they will still have to
find the ten to fifteen minutes to draw up their report, but maybe we
can increase our coverage of all that is going on in the community.

Feel free to circulate this announcement further in order to
reach people who might otherwise not see it. Enjoy!

Janis Voigtlaender
<hcar at haskell.org>

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

definition and propagation of class constraints

2009-11-18T15:59:31Z

Hi,

I want to to this:
------------------ umatrix.dcl ---------------------------------------------------------------------
definition module UMatrix

import StdArray
// UMatrix : Unboxed matrix, elemType must be one of the available unboxed types
::UMatrix elemType | Array {#} elemType

// creates a new 2d matrix with given initial value
make :: .Int .Int elemType -> .(UMatrix elemType)
... more stuff ...
----------------------------------------------------------------------------------------------------------

but I don't know (couldn't find) how to define the abstract type UMatrix in the definition module, annotated with corresponding class constraint.

------------------- umatrix.icl ----------------------------------------------------------------------
implementation module UMatrix

import StdArray, StdInt, StdBool, StdMisc, StdList, StdEnum

::UMatrix elemType = { rows :: Int
, cols :: Int
, vals :: {#} elemType
}

make :: .Int .Int elemType -> .(UMatrix elemType)
make n m v
| n > 0 && m > 0 = { rows = n
, cols = m
, vals = createArray (n*m) v
}
= abort "invalid matrix dimension"
... more stuff ...
---------------------------------------------------------------------------------------------------------

therefore the compiler complains that "internal overloading of createArray" cannot be solved.

My questions
- if UMatrix e is annotated with Array {#} e, why do I need to especify that in make if e appears in the return type? Isn't this inferred?
- Is that solved if I manage to annotate UMatrix in the implementation file?

kind regards
Carlos

__________________________________________________________________________________
Get more done like never before with Yahoo!7 Mail.
Learn more: http://au.overview.mail.yahoo.com/

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

Call for Participation - PEPM'10 (co-located with POPL'10)

2009-11-18T09:29:37Z

===============================================================
CALL FOR PARTICIPATION
ACM SIGPLAN 2010 Workshop on
Partial Evaluation and Program Manipulation (PEPM'10)
Madrid, January 18-19, 2010

(Affiliated with POPL'10)

http://www.program-transformation.org/PEPM10
===============================================================

Abstracts of all papers and presentations are available from the
above web site.

INVITED TALKS:

* Lennart Augustsson (Standard Chartered Bank, UK)
Title: O, Partial Evaluator, Where Art Thou?

* Jeremy Siek (University of Colorado at Boulder, USA)
Title: General Purpose Languages Should be Metalanguages.

CONTRIBUTED TALKS:

* Nabil el Boustani and Jurriaan Hage.
Corrective Hints for Type Incorrect Generic Java Programs.

* Johannes Rudolph and Peter Thiemann.
Mnemonics: Type-safe Bytecode Generation at Run Time.

* Elvira Albert, Miguel Gomez-Zamalloa and German Puebla.
PET: A Partial Evaluation-based Test Case Generation Tool for Java
Bytecode.

* Martin Hofmann.
Igor2 - an Analytical Inductive Functional Programming System.

* José Pedro Magalhães, Stefan Holdermans, Johan Jeuring and Andres Löh.
Optimizing Generics Is Easy!

* Michele Baggi, María Alpuente, Demis Ballis and Moreno Falaschi.
A Fold/Unfold Transformation Framework for Rewrite Theories extended to
CCT.

* Hugh Anderson and Siau-Cheng KHOO.
Regular Approximation and Bounded Domains for Size-Change Termination.

* Évelyne Contejean, Pierre Courtieu, Julien Forest, Andrei Paskevich,
Olivier Pons and Xavier Urbain.
A3PAT, an Approach for Certified Automated Termination Proofs.

* Fritz Henglein.
Optimizing Relational Algebra Operations Using Generic Equivalence
Discriminators and Lazy Products.

* Adrian Riesco and Juan Rodriguez-Hortala.
Programming with Singular and Plural Non-deterministic Functions.

* Martin Hofmann and Emanuel Kitzelmann.
I/O Guided Detection of List Catamorphisms.

* Andrew Moss and Dan Page.
Bridging the Gap Between Symbolic and Efficient AES Implementations.

* Christopher Brown and Simon Thompson.
Clone Detection and Elimination for Haskell.

* Stefan Holdermans and Jurriaan Hage.
Making Stricterness More Relevant.

* Arun Lakhotia, Davidson Boccardo, Anshuman Singh and Aleardo Manacero
Júnior.
Context-Sensitive Analysis of Obfuscated x86 Executables.

* Xin Li and Mizuhito Ogawa.
Conditional Weighted Pushdown Systems and Applications.

* Ivan Lazar Miljenovic.
The SourceGraph Program.

* Florian Haftmann.
From Higher-Order Logic to Haskell: There and Back Again.

SPECIAL FEATURE:

* Andy Gill, Garrin Kimmell and Kevin Matlage.
Capturing Functions and Catching Satellites.

IMPORTANT DATES:

* Early registration deadline: December 22, 2009
* Hotel registration deadline: December 28, 2009

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

ICFP '10: Second call for workshop proposals

2009-11-18T03:13:38Z

CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS
ICFP 2010
15th ACM SIGPLAN International Conference on Functional Programming
September 27 - 29, 2010
Baltimore, Maryland
http://www.icfpconference.org/icfp2010

The 15th ACM SIGPLAN International Conference on Functional
Programming will be held in Baltimore, Maryland on September 27-29,
2010. ICFP provides a forum for researchers and developers to hear
about the latest work on the design, implementations, principles, and
uses of functional programming.

Proposals are invited for workshops (and other co-located events, such
as tutorials) to be affiliated with ICFP 2010 and sponsored by
SIGPLAN. These events should be more informal and focused than ICFP
itself, include sessions that enable interaction among the attendees,
and be fairly low-cost. The preference is for one-day events, but
other schedules can also be considered.

----------------------------------------------------------------------

Submission details
Deadline for submission: November 20, 2009
Notification of acceptance: December 18, 2009

Prospective organizers of workshops or other co-located events are
invited to submit a completed workshop proposal form in plain text
format to the ICFP 2010 workshop co-chairs (Derek Dreyer and Chris
Stone), via email to icfp10-workshops at mpi-sws.org by November 20,
2009. (For proposals of co-located events other than workshops,
please fill in the workshop proposal form and just leave blank any
sections that do not apply.) Please note that this is a firm
deadline.

Organizers will be notified if their event proposal is accepted by
December 18, 2009, and if successful, depending on the event, they
will be asked to produce a final report after the event has taken
place that is suitable for publication in SIGPLAN Notices.

The proposal form is available at:

http://www.icfpconference.org/icfp2010/icfp10-workshops-form.txt

Further information about SIGPLAN sponsorship is available at:

http://acm.org/sigplan/sigplan_workshop_proposal.htm

----------------------------------------------------------------------

Selection committee

The proposals will be evaluated by a committee comprising the
following members of the ICFP 2010 organizing committee, together with
the members of the SIGPLAN executive committee.

Workshop Co-Chair: Derek Dreyer (MPI-SWS)
Workshop Co-Chair: Chris Stone (Harvey Mudd College)
General Chair: Paul Hudak (Yale University)
Program Chair: Stephanie Weirich (University of Pennsylvania)

----------------------------------------------------------------------

Further information

Any queries should be addressed to the workshop co-chairs (Derek
Dreyer and Chris Stone), via email to icfp10-workshops at mpi-sws.org.
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: uniqueness question

2009-11-17T15:48:12Z

Thanks Edsko and John for your explanations.

Certainly I had a big misunderstanding in regards to unification and uniqueness. In a signature like

updateLoop_ :: *(a e) .(e Int -> e) Int Int -> *(a e) | Array a e
updateLoop_ arr1 f pos maxPos
| pos == maxPos = arr1
# (v, arr1) = arr1![pos]
= {(updateLoop_ arr1 f (pos+1) maxPos) & [pos] = f v pos}

Although f certainly appears twice, I thought that the don't care attribute in .(e Int -> e) was going to be resolved by the compiler saying "well, s/he doesn't care, but I know is not unique, so let's _instantiate_ that unknown variable with non-unique". I was wrong.

For completeness, let me c&p the working solution,
****************************************************
module test1

import StdArray, StdInt, StdReal, StdClass

Start :: {#Real}
Start = addInPlace v1 v2
where
v1 :: .{#Real}
v1 = {1.0, 2.0, 3.0}
v2 :: .{#Real}
v2 = {0.0, 2.0, 4.5}

addInPlace :: *(a e) .(b e) -> *(a e) | Array a e & Array b e & Arith e
addInPlace arr1 arr2 = updateInPlace arr1 f (size arr2)
where
f v p = v + arr2.[p]

updateInPlace :: *(a e) (e Int -> e) Int -> *(a e) | Array a e
updateInPlace arr1 f maxPos = updateLoop_ arr1 f 0 maxPos
where
updateLoop_ :: *(a e) (e Int -> e) Int Int -> *(a e) | Array a e
updateLoop_ arr1 f pos maxPos
| pos == maxPos = arr1
# (v, arr1) = arr1![pos]
= {(updateLoop_ arr1 f (pos+1) maxPos) & [pos] = f v pos}
****************************************************

I think I am ready to understake my challenge, a simple in-place matrix library.

Kind regards
Carlos

----- Original Message ----
From: Edsko de Vries <edskodevries@...>
To: Carlos Aya <carlosayam@...>
Cc: John van Groningen <johnvg@...>; clean-list@...
Sent: Tue, 17 November, 2009 9:10:56 PM
Subject: Re: [clean-list] uniqueness question

Hi Carlos,

On 17 Nov 2009, at 01:13, Carlos Aya wrote:

> Well, what I want to achieve is a more generic 'update in place' for arrays. For example, to implement something like "v1 += v2" for arrays.
>
> My current attempt goes like this
>
> -----------------------------------------------------------
> . . .
>
> addInPlace :: *(a e) .(b e) -> *(a e) | Array a e & Array b e
> addInPlace arr1 arr2 = updateInPlace arr1 (\v p = v + arr2.[p]) (size arr2)
>
> updateInPlace :: *(a e) .(e Int -> e) Int -> *(a e) | Array a e
> updateInPlace arr1 f maxPos = updateLoop_ arr1 f 0 maxPos
>
> updateLoop_ :: *(a e) .(e Int -> e) Int Int -> *(a e) | Array a e
> updateLoop_ arr1 f pos maxPos
> | pos == maxPos = arr1
> # (v, arr1) = arr1![pos]
> = {(updateLoop_ arr1 f (pos+1) maxPos) & [pos] = f v pos}
>
> -----------------------------------------------------------

Right, so this is an example of what John was talking about. Functions are treated special in Clean (little tongue in cheek: some might argue too special [1]). A unique function cannot be coerced to a non-unique function. Suppose that in the lambda expression you create in addInPlace, you don't just read from arr2 but you write to it. Then we have a closure (a partially applied function) with a unique element (arr2) in its closure. Clearly, this function should only be executed once if we want to have referential transparency - if we execute it twice, then the first execution modifies the array, and then the second execution starts with a *different* array.

Since updateLoop executes f more than once, f must be non-unique (hence the type that Clean has inferred).

Since f must be non-unique, the function that you pass it in addInPlace must also be non-unique. As a consequence, arr2 must be non-unique in addInPlace -- even though you only read from it. I think you won't be able to get around that even with a strict-let-before (but I'm not 100% sure) -- I'm guessing you need a more powerful type system (such as observer types) to be able to do that. (You might however be able to provide a wrapper function that accepts a unique arr2, and then calls addInPlace, since unique arrays are coercible to non-unique arrays).

> John, I read the paper and still don't get it.
> Could you please provide an example? Also, it seems to suggest that the
> types of
> f :: *a .b -> *a
> and
> g :: .b *a -> *a
> could be treated differently as in the last one only the last parameter
> is unique and therefore there is no risk in creating a partial
> application that violates single threaded semantics. Am I right? Is it
> like that in Clean?

Note that the "dot" does not mean non-unique, but rather means "there is a uniqueness variable here that I don't care to name". Your types of f and g expand to

f :: *a u:b -> *a
g :: u:b *a -> *a

To indicate non-unique, you use no annotation at all:

f :: *a b -> *a
g :: b *a -> *a

If we assume the latter definition, then yes, there is a difference. An application (f x) must be applied to a unique x, and threfore will be a partially applied function with a unique element in its closure -- that is, it will be a unique function that can only be applied once. Conversely, (g x) will be applied to a non-unique x and is therefore not subject to such a contraint.

Hope that helps. You can find much more information about uniqueness typing (and more examples) in Section 3.2 of [1]. It also discusses the above problem in great depth.

Edsko

[1]. Making Uniqueness Typing Less Unique, Edsko de Vries, PhD Thesis, Trinity College Dublin, Ireland

__________________________________________________________________________________
Get more done like never before with Yahoo!7 Mail.
Learn more: http://au.overview.mail.yahoo.com/

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

Re: uniqueness question

2009-11-17T07:05:08Z

Carlos Aya wrote:
>Well, what I want to achieve is a more generic 'update in place' for arrays. For example, to implement something like "v1 += v2" for arrays. My current attempt goes like this ----------------------------------------------------------- . . . addInPlace :: *(a e) .(b e) -> *(a e) | Array a e & Array b e addInPlace arr1 arr2 = updateInPlace arr1 (\v p = v + arr2.[p]) (size arr2) updateInPlace :: *(a e) .(e Int -> e) Int -> *(a e) | Array a e updateInPlace arr1 f maxPos = updateLoop_ arr1 f 0 maxPos updateLoop_ :: *(a e) .(e Int -> e) Int Int -> *(a e) | Array a e updateLoop_ arr1 f pos maxPos | pos == maxPos = arr1 # (v, arr1) = arr1![pos] = {(updateLoop_ arr1 f (pos+1) maxPos) & [pos] = f v pos} ----------------------------------------------------------- I am getting this error... Overloading error [test1.icl,7,addInPlace]: internal overloading of "lambda [line 8]" could not be solved.

Because + is also overloaded. Adding "| + e" to the type of addInPlace
should fix this.

>which probably displays my ignorance. [You get the idea, this should be a closure with arr2 inside, v comes from the actual value in arr1 at p. See functions below.] But the funny thing is the error with updateLoop_, have a look... Type error [test1.icl,13,updateLoop_]:derived type conflicts with specified type: *(a b) (b -> Int -> b) Int Int -> *(a b) | Array a b *(a b) .(b -> Int -> b) Int Int -> *(a b) | Array a b The two types are identical BUT the function parameter (e Int -> e) has attribute any "." in my signature and _no_ attribute in the inferred type. If I change my signature and remove the uniqueness attribute for f [in updateLoop_ and updateInPlace], it passes. What's wrong here?

Edsko has already explained this.

>John, I read the paper and still don't get it. Could you please provide an example?

f :: *{#Int} Int -> Int
f a i
# (a0,a) = a![0]
a = {a & [0]=a0+1}
= a.[i]

g1 a
# h = f a
= h 0

g2 a
# h = f a
= h 0 + h 0

The function h in g1 contains a unique array, and may therefore
only be used once. g1 uses h just once, so is accepted by the typechecker.

g2 tries to use h twice, this is not allowed, because the first call
of f would change the array, then the second call of f gets this updated
array instead of the original array, and the result of the function would
be incorrect.

>..

Kind regards,

John van Groningen
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: uniqueness question

2009-11-17T06:43:51Z

Vag Vagoff wrote:

>It is very convenient to use
>
> class (+) infixl 6 a :: !*a !a -> .a
>

Unfortunately if the compiler would permit this type and if 'a' cannot be
coerced the following functions would be rejected by the typechecker:

f a b = a+(b+a) // because a cannot have type *a and a

g a b c
# x = a+b
| True
= x+c
= c+x
// x cannot have type *a and a in different alternatives

Kind regards,

John van Groningen
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: uniqueness question

2009-11-17T02:10:56Z

Hi Carlos,

On 17 Nov 2009, at 01:13, Carlos Aya wrote:

Note that the "dot" does not mean non-unique, but rather means "there is a uniqueness variable here that I don't care to name". Your types of f and g expand to

f :: *a u:b -> *a
g :: u:b *a -> *a

To indicate non-unique, you use no annotation at all:

f :: *a b -> *a
g :: b *a -> *a

If we assume the latter definition, then yes, there is a difference. An application (f x) must be applied to a unique x, and threfore will be a partially applied function with a unique element in its closure -- that is, it will be a unique function that can only be applied once. Conversely, (g x) will be applied to a non-unique x and is therefore not subject to such a contraint.

Hope that helps. You can find much more information about uniqueness typing (and more examples) in Section 3.2 of [1]. It also discusses the above problem in great depth.

Edsko

[1]. Making Uniqueness Typing Less Unique, Edsko de Vries, PhD Thesis, Trinity College Dublin, Ireland
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: uniqueness question

2009-11-17T00:09:12Z

I've collected papers about uniqueness typing at

http://sites.google.com/site/vagvagoff/UniquenessAndLinearTypes.tar.bz2

(download it by browser, not wget -- there are some weird redirections)

file|year|title|authors
10.1.1.36.5927 (Conventional and UT in GRS).pdf|1993|Conventional and Uniqueness Typing in Graph Rewrite Systems|Erik Barendsen,Sjaak Smetsers
barendsen93conventional.pdf|1993|Conventional and Uniqueness Typing in Graph Rewrite Systems|Erik Barendsen,Sjaak Smetsers
smes94-guaranteeing.pdf|1994|Guaranteeing Safe Destructive Updates through a Type System with Uniqueness Information for Graphs|Sjaak Smetsers,Erik Barendsen,Marko van Eekelen,Rinus Plasmeijer
10.1.1.36.3125 (Guaranteeing Safe Destructive Updates).pdf|1994|Guaranteeing Safe Destructive Updates through a Type System with Uniqueness Information for Graphs|Sjaak Smetsers,Erik Barendsen,Marko van Eekelen,Rinus Plasmeijer
10.1.1.36.5837 (In Theory and Practice).pdf|1994|Uniqueness Types in Theory and Practice|Erik Barendsen,Sjaak Smetsers
10.1.1.53.4191 (Derivation System).pdf|1995|A Derivation System for Uniqueness Typing|Erik Barendsen,Sjaak Smetsers
bare96-uniclosed.pdf|1996|Uniquness Typing for Functional Languages with Graph Rewriting Semantics|Erik Barendsen,Sjaak Smetsers
groj97-Arrays.pdf|1997|The Implementation and Efficiency of Arrays in Clean 1.1|John H. G. van Groningen
28-Deviansky-UniqueIdentifiersInPureFunctionalLanguages.pdf|2006|Unique Identifiers in Pure Functional Languages|Peter Devianszky
vrie2007-IFL06-UniquenessTypingRedefinedRev.pdf|2006|Uniqueness Typing Redefined|Edsko de Vries,Rinus Plasmeijer,David Abrahamson
vrie2007-IFL06-UniquenessTypingRedefinedRev-.pdf|2006|Uniqueness Typing Redefined|Edsko de Vries,Rinus Plasmeijer,David Abrahamson
vrie08-IFL07-UniquenessTypingSimplified-.pdf|2007|Uniqueness Typing Simplified|Edsko de Vries,Rinus Plasmeijer,David Abrahamson
vrie2007-TFP07-EqualityBasedUniquenessTyping.pdf|2007|Equality Based Uniqueness Typing|Edsko de Vries,Rinus Plasmeijer,David Abrahamson
vrie2007-TFP07-EqualityBasedUniquenessTyping-.pdf|2007|Equality Based Uniqueness Typing|Edsko de Vries,Rinus Plasmeijer,David Abrahamson
vrie08-IFL07-UniquenessTypingSimplified.pdf|2007|Uniqueness Typing Simplified|Edsko de Vries,Rinus Plasmeijer,David Abrahamson
fpottier-2007-05-linear-bestiary.pdf|2007|Wandering through linear types, capabilities, and regions|Francois Pottier
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: uniqueness question

2009-11-16T21:53:20Z

It is very convenient to use

class (+) infixl 6 a :: !*a !a -> .a

for example,

instance + BigInt where (+) a b = add_inplace_UB_B a b

thus,

fn1 :: *a .a -> *a | + a
fn2 :: v:a u:a -> v:a | SomeClass a , [v <= u]

are quite possible in real programs.

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

Re: uniqueness question

2009-11-16T17:13:40Z

Well, what I want to achieve is a more generic 'update in place' for arrays. For example, to implement something like "v1 += v2" for arrays.

My current attempt goes like this

-----------------------------------------------------------
. . .

addInPlace :: *(a e) .(b e) -> *(a e) | Array a e & Array b e
addInPlace arr1 arr2 = updateInPlace arr1 (\v p = v + arr2.[p]) (size arr2)

updateInPlace :: *(a e) .(e Int -> e) Int -> *(a e) | Array a e
updateInPlace arr1 f maxPos = updateLoop_ arr1 f 0 maxPos

updateLoop_ :: *(a e) .(e Int -> e) Int Int -> *(a e) | Array a e
updateLoop_ arr1 f pos maxPos
| pos == maxPos = arr1
# (v, arr1) = arr1![pos]
= {(updateLoop_ arr1 f (pos+1) maxPos) & [pos] = f v pos}

-----------------------------------------------------------

I am getting this error...

Overloading error [test1.icl,7,addInPlace]: internal overloading of "lambda [line 8]" could not be solved.

which probably displays my ignorance. [You get the idea, this should be a closure with arr2 inside, v comes from the actual value in arr1 at p. See functions below.]

But the funny thing is the error with updateLoop_, have a look...

Type error [test1.icl,13,updateLoop_]:derived type conflicts with specified type:
*(a b) (b -> Int -> b) Int Int -> *(a b) | Array a b
*(a b) .(b -> Int -> b) Int Int -> *(a b) | Array a b

The two types are identical BUT the function parameter (e Int -> e) has attribute any "." in my signature and _no_ attribute in the inferred type. If I change my signature and remove the uniqueness attribute for f [in updateLoop_ and updateInPlace], it passes. What's wrong here?

John, I read the paper and still don't get it.
Could you please provide an example? Also, it seems to suggest that the
types of
f :: *a .b -> *a
and
g :: .b *a -> *a
could be treated differently as in the last one only the last parameter
is unique and therefore there is no risk in creating a partial
application that violates single threaded semantics. Am I right? Is it
like that in Clean?

Kind regards
Carlos

--- Original Message ----
From: Edsko de Vries <edskodevries@...>
To: John van Groningen <johnvg@...>
Cc: Carlos Aya <carlosayam@...>; clean-list@...
Sent: Tue, 17 November, 2009 3:05:34 AM
Subject: Re: [clean-list] uniqueness question

Hey,

On 16 Nov 2009, at 15:57, John van Groningen wrote:

> Carlos Aya wrote:
>> Does anyone know why the following type signature is invalid?
>>
>> second :: *a .a -> *a
>> second x y = x
>>
>> I am getting this message
>> Error [matrices.icl,12,second]: a inconsistently attributed (4)
>
> The same uniqueness attribute must be used for all occurrences of
> a type variable in a function type.
>
>> I came across this trying to type a more complex function with arrays, but it boils down to signature above.
>> Why the uniqueness attribute has to be the same for two independent parameters that just happen to have the same type?
>
> A type '*a' cannot be coerced to 'a', because 'a' could be a partial
> application with a unique argument. It this were allowed the unique
> argument could be used more than once. Because the opposite coercion
> (from 'a' to '*a') is also not possible, the compiler requires that
> all occurences of a type variable have the same uniqueness attribute
> (as mentioned above).

While all of that is true, it still does not explain why all occurrences of a type variable need the same attribute. For instance, there is absolutely no problem with

second :: *a .a -> *a
second x y = x

Edsko

__________________________________________________________________________________
Get more done like never before with Yahoo!7 Mail.
Learn more: http://au.overview.mail.yahoo.com/

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

TFP 2010 - Call for Papers

2009-11-16T16:58:29Z

TFP 2010: 11th SYMPOSIUM ON TRENDS IN FUNCTIONAL PROGRAMMING
May 17-19, 2010
University of Oklahoma
http://www.cs.ou.edu/tfp2010/

The Program Committee for TFP 2010 seeks papers on trends in functional
programming. The symposium is an international forum for researchers with
interests in all aspects of functional programming. It embraces a broad
view of current and future trends in functional programming and aspires to
be a lively environment for presenting the latest research results. TFP
considers both full papers and extended abstracts for presentation at the
symposium. A formal refereeing process after the symposium selects the
best presentations for publication in a high-profile volume.

IMPORTANT DATES
* Apr 2: Submission of papers and abstracts
* Apr 14: Notification of acceptance
* May 7: Camera-ready, full papers for draft proceedings
* May 17-19: TFP Symposium

SCOPE OF THE SYMPOSIUM
Articles must be original and not submitted to any other forum for
publication. They may consider any aspect of functional programming.
Theory, implementation, experience, applications, and the use of
functional programming methods in other languages all lie within the scope
of the symposium.

Articles may fall in any of the following categories:
* Research: leading-edge, previously unpublished research
* Position: advocating or critiquing new trends
* Project: descriptions of new or recently initiated projects
* Evaluation: lessons drawn from completed projects
* Overview: summaries of trendy work

A list of suggested topics and other details concerning submissions can be
found on the symposium website:
http://www.cs.ou.edu/tfp2010/call.html#topics
The suggested topics are extensive but by no means exhaustive. Please
contact the program chair, Rex Page, tfp2010@..., if you are in
doubt about whether your topic is within the TFP scope.

BEST STUDENT PAPER AWARD
TFP traditionally pays special attention to research conducted by
students, acknowledging that students commonly develop new subject trends.
A prize for the best student paper is awarded each year.

SUBMISSION AND DRAFT PROCEEDINGS
Full papers (up to 15 pages) and extended abstracts (3 to 6 pages, to be
expanded to full papers if accepted) submitted for presentation at the
symposium are screened by the program committee. A draft proceedings
available at the conference will contain all accepted papers and all
accepted abstracts that have been expanded to full papers. Each submission
must declare its category (research, position, project, evaluation, or
overview).

Authors who are students should so indicate when they submit their
article. The Program Committee will provide extra feedback for student
papers to help compensate for differences between students and other
researchers in experience with the publication process.

POST-SYMPOSIUM REFEREEING AND PUBLICATION
In addition to the draft symposium proceedings, we intend to continue the
TFP tradition of publishing a high-quality volume containing the best
papers from the symposium. All TFP authors will be invited to submit
revised papers after the symposium. These will be refereed using normal
conference standards, and the best papers will be selected for
publication. Papers will be judged on their contributions with appropriate
criteria applied to each category of paper.

Rex Page, University of Oklahoma, Program Chair
Viktia Zs and Zolt Horvath, Ev Lord University, Symposium Co-Chairs
Program Committee
Peter Achten, Radboud University Nijmegen, NL
Emil Axelsson, Chalmers University of Technology, SE
Francesco Cesarini, Erlang Training and Consulting Ltd, UK
John Clements, California Polytechnic State University, USA
Daniel Cooke, Texas Tech University, USA
Nils Anders Danielsson, University of Nottingham, UK
Jared Davis, Centaur Technology, USA
Martin Erwig, Oregon State University, USA
Ruben Gamboa, University of Wyoming, USA
Jurriaan Hage, Utrecht University, NL
Kevin Hammond, University of St Andrews, UK
Michael Hanus, Christian Albrechts University zu Kiel, DE
Zolt Horvath, Ev Lord University, HU
Garrin Kimmell, University of Kansas, USA
Pieter Koopman, Radboud University Nijmegen, NL
Hans-Wolfgang Loidl, Ludwig Maximilians University Mchen, DE
Rita Loogen, Philipps University Marburg, DE
Jay McCarthy, Brigham Young University, USA
Greg Michaelson, Heriot-Watt University, UK
Marco T. Moraz, Seton Hall University, USA
Rodney Oldehoeft, Krell Institute, USA
Walid Taha, Rice University, USA
Sam Tobin-Hochstadt, Northeastern University, USA
Simon Thompson, University of Kent, UK
Phil Trinder, Heriot-Watt University, UK
Marko van Eekelen, Radboud University Nijmegen, NL
Viktia Zs, Ev Lord University, HU

SPONSORS
The University of Oklahoma
Erlang Training and Consulting
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

CICE-2010: Call for Papers

2009-11-16T10:31:34Z

Kindly email this call for papers to your colleagues,
faculty members and postgraduate students.

Apologies for cross-postings.

CALL FOR PAPERS

Canada International Conference on Education (CICE-2010),
April 26-28, 2010, Toronto, Canada (www.ciceducation.org)

The CICE is an international refereed conference dedicated
to the advancement of the theory and practices in education.
The CICE promotes collaborative excellence between academicians
and professionals from Education.

The aim of CICE is to provide an opportunity for academicians
and professionals from various educational fields with
cross-disciplinary interests to bridge the knowledge gap, promote
research esteem and the evolution of pedagogy. The CICE 2010 invites
research papers that encompass conceptual analysis, design
implementation and performance evaluation. All the accepted papers
will appear in the proceedings and modified version of selected
papers willbe published in special issues peer reviewed journals.

The topics in CICE-2009 include but are not confined to the
following areas:

*Academic Advising and Counselling
*Art Education
*Adult Education
*APD/Listening and Acoustics in Education Environment
*Business Education
*Counsellor Education
*Curriculum, Research and Development
*Competitive Skills
*Continuing Education
*Distance Education
*Early Childhood Education
*Educational Administration
*Educational Foundations
*Educational Psychology
*Educational Technology
*Education Policy and Leadership
*Elementary Education
*E-Learning
*E-Manufacturing
*ESL/TESL
*E-Society
*Geographical Education
*Geographic information systems
*Health Education
*Higher Education
*History
*Home Education
*Human Computer Interaction
*Human Resource Development
*Indigenous Education
*ICT Education
*Internet technologies
*Imaginative Education
*Kinesiology & Leisure Science
*K12
*Language Education
*Mathematics Education
*Mobile Applications
*Multi-Virtual Environment
*Music Education
*Pedagogy
*Physical Education (PE)
*Reading Education
*Writing Education
*Religion and Education Studies
*Research Assessment Exercise (RAE)
*Rural Education
*Science Education
*Secondary Education
*Second life Educators
*Social Studies Education
*Special Education
*Student Affairs
*Teacher Education
*Cross-disciplinary areas of Education
*Ubiquitous Computing
*Virtual Reality
*Wireless applications
*Other Areas of Education

For further information please visit CICE-2010
at www.ciceducation.org

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

Re: uniqueness question

2009-11-16T08:55:53Z

Edsko de Vries wrote:
>While all of that is true, it still does not explain why all occurrences of a type variable need the same attribute. For instance, there is absolutely no problem with
>
>second :: *a .a -> *a
>second x y = x

I think you are right, but I am not expert in type systems. I also
don't like this restriction.

However, I doubt that removing the same attribute restriction will
improve the type system much. For example, if someone would
define a function 'f' with type

f :: a -> *a | Eq a

he would probably expect that the typechecker will accept:

g x = f (f x)

but because '*a' cannot be coerce to 'a' this is not allowed.

This might be more confusing for a programmer than a simple attribute
restriction.

The main problem with this restriction seems to occur in combination
with overloading. For example, it prevents class definitions like:

class T a where
g :: a -> *a

Maybe this can be fixed by allowing only instances of types that
can be coerced (something similar is implemented for the Array class).

Kind regards,

John van Groningen
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Re: uniqueness question

2009-11-16T08:05:34Z

Hey,

On 16 Nov 2009, at 15:57, John van Groningen wrote:

While all of that is true, it still does not explain why all occurrences of a type variable need the same attribute. For instance, there is absolutely no problem with

second :: *a .a -> *a
second x y = x

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

Re: uniqueness question

2009-11-16T07:57:02Z

Re: [clean-list] uniqueness question

Carlos Aya wrote:

Does anyone know why the following type signature is invalid?

second :: *a .a -> *a
second x y = x

I am getting this message

Error [matrices.icl,12,second]: a inconsistently attributed (4)

The same uniqueness attribute must be used for all occurrences of

a type variable in a function type.

I came across this trying to type a more complex function with arrays, but it boils down to signature above.

Why the uniqueness attribute has to be the same for two independent parameters that just happen to have the same type?

A type '*a' cannot be coerced to 'a', because 'a' could be a partial

application with a unique argument. It this were allowed the unique

argument could be used more than once. Because the opposite coercion

(from 'a' to '*a') is also not possible, the compiler requires that

all occurences of a type variable have the same uniqueness attribute

(as mentioned above).

This is explained in section "Higher-Order Uniqueness Types" (page 18) of:

Barendsen, Erik and Smetsers, Sjaak. Uniqueness typing for functional languages with graph rewriting semantics, In Mathematical Structures in Computer Science 6, pp. 579-612. (abstract, pdf version)

http://www.st.cs.ru.nl/papers/1996/bare96-uniclosed.pdf

Kind regards,

John van Groningen

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

Re: uniqueness question

2009-11-16T02:38:54Z

All occurrences of the same type variable must have the same uniqueness attribute. I've never been able to figure out the why.

Edsko

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

uniqueness question

2009-11-15T19:04:00Z

Hi,

Does anyone know why the following type signature is invalid?

second :: *a .a -> *a
second x y = x

I am getting this message
Error [matrices.icl,12,second]: a inconsistently attributed (4)

I came across this trying to type a more complex function with arrays, but it boils down to signature above.

Why the uniqueness attribute has to be the same for two independent parameters that just happen to have the same type?

A workaround I found was to use two different type variables, like
second :: *a .b -> *a
which will work properly on usage site by unification, but still I was wondering what the problem was with the first one.

regards
Carlos

__________________________________________________________________________________
Win 1 of 4 Sony home entertainment packs thanks to Yahoo!7.
Enter now: http://au.docs.yahoo.com/homepageset/

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

Second call for papers: Mathematics of Program Construction

2009-11-14T08:29:22Z

SECOND CALL FOR PAPERS

10th International Conference on
Mathematics of Program Construction
MPC 2010

Québec City, Canada, 21-23 June 2010

http://mpc-amast2010.fsg.ulaval.ca/

Colocated with AMAST 2010 (23-26 June 2010)

BACKGROUND

The biennial MPC conferences aim to promote the development of
mathematical principles and techniques that are demonstrably practical
and effective in the process of constructing computer programs. Topics
of interest range from algorithmics to support for program
construction in programming languages and systems.

The previous conferences were held in Twente, The Netherlands (1989),
Oxford, UK (1992), Kloster Irsee, Germany (1995), Marstrand, Sweden
(1998), Ponte de Lima, Portugal (2000), Dagstuhl, Germany (2002),
Stirling, UK (2004, colocated with AMAST '04), Kuressaare, Estonia
(2006, colocated with AMAST '06) and Marseille, France (2008).
The 2010 conference will be held in Lac-Beauport, a suburb of Québec
City, Canada, and will be colocated with AMAST '10 (23-26 June 2010).

INVITED SPEAKERS

Roland Backhouse, University of Nottingham, UK.
Others to be announced later.

IMPORTANT DATES

* Submission of abstracts: 7 December 2009
* Submission of full papers: 14 December 2009
* Notification of authors: 20 February 2010
* Camera-ready version: 20 March 2010

TOPICS

Papers are solicited on mathematical methods and tools put to use in
program construction. Topics of interest range from algorithmics to
support for program construction in programming languages and
systems. Some typical areas are type systems, program analysis and
transformation, programming-language semantics, security and program
logics. Theoretical contributions are welcome provided their relevance
for program construction is clear. Reports on applications are welcome
provided their mathematical basis is evident.

SUBMISSION

Submission is in two stages. Abstracts (plain text, 10 to 20 lines)
must be submitted by 7 December 2009. Full papers (pdf) adhering to
the LaTeX llncs style must be submitted by 14 December 2009. There
is no official page limit, but authors should strive for brevity.
The web-based system EasyChair will be used for submission
(https://www.easychair.org/login.cgi?conf=mpc2010).

Papers must report previously unpublished work and not be submitted
concurrently to another conference with refereed proceedings. In
particular, they must not be submitted to AMAST 2010. Accepted
papers must be presented at the conference by one of the authors.

The proceedings of MPC'10 will be published in the Lecture Notes in
Computer Science series of Springer-Verlag.

After the conference, the authors of the best papers will be invited
to submit revised versions to a special issue of the Science of
Computer Programming journal of Elsevier.

PROGRAMME COMMITTEE

Jules Desharnais Université Laval, Québec, Canada (chair)

Philippe Audebaud Ecole Normale Supérieure Lyon, France
Ralph-Johan Back Abo Akademi University, Finland
Eerke Boiten University of Kent, UK
Sharon Curtis Oxford Brookes University, UK
Jeremy Gibbons University of Oxford, UK
Lindsay Groves Victoria University of Wellington, New Zealand
Ian Hayes University of Queensland, Australia
Eric Hehner University of Toronto, Canada
Zhenjiang Hu National Institute of Informatics, Japan
Johan Jeuring Utrecht University, Netherlands
Christian Lengauer Universität Passau, Germany
Bernhard Möller Universität Augsburg, Germany
Shin-Cheng Mu Academia Sinica, Taiwan
David Naumann Stevens Institute of Technology, USA
José Nuno Oliveira Universidade do Minho, Portugal
Alberto Pardo Universidad de la República, Uruguay
Christine Paulin-Mohring INRIA-Université Paris-Sud, France
Steve Reeves University of Waikato, New Zealand
Tim Sheard Portland State University, USA
Georg Struth Sheffield University, UK
Tarmo Uustalu Institute of Cybernetics, Estonia

VENUE

The conference will be held in the Manoir St-Castin
(http://www.hotelsvillegia.com/villegia_stcastin/pages-eg/).
This resort is located on the shore of Beauport lake,
15 minutes from downtown Québec City (http://www.quebecregion.com/e/)
and 15 minutes from the Jean-Lesage International Airport.

LOCAL ORGANIZERS

The local organizers are Claude Bolduc, Jules Desharnais and Béchir Ktari.

Enquiries regarding the programme (submission, etc.) should be addressed
to Jules.Desharnais@....
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

Description Logics 2010: 1st call for papers

2009-11-12T07:58:53Z

----------------------------------------------------------------------

23rd International Workshop on Description Logics (DL 2010)
FIRST CALL FOR PAPERS
Waterloo, Ontario, Canada

http://www.cs.uwaterloo.ca/conferences/dl2010/

The DL workshop is the major annual event of the description logic
research community. The workshop is the premier forum to meet, discuss
and exchange experiences among all those, both in the academia and
industry, who are interested in description logics and their
applications.

----------------------------------------------------------------------

IMPORTANT DATES

Paper submission deadline: January 26th, 2010
Acceptance notification: March 9th, 2010
Camera ready copies: March 30th, 2010
Early registration: March 30th, 2010
Workshop: May 4 to May 7th

----------------------------------------------------------------------

WORKSHOP SCOPE

We invite contributions on all aspects of description logics,
such as

* foundations of description logics, including expressive power,
decidability and complexity of reasoning, novel inference problems,
and reasoning techniques for solving these problems;

* extensions of description logics, including, but not limited to,
closed-world and nonmonotonic reasoning, defaults, epistemic
reasoning, temporal and spatial reasoning, procedural knowledge, and
query languages;

* integration of description logics with other formalisms, such as
object-oriented representation languages, database query languages,
constraint-based programming, logic programming, and rule-based
systems;

* use of description logics in applications or areas such as ontology
engineering, ontology languages, databases, semi-structured data,
document management, natural language, learning, planning, semantic
web, and grid computing;

* building systems based on description logics, with special emphasis
on optimization and implementation techniques; and

* tools that exploit description logic reasoning, such as ontology
editors, database schema design, query optimization, and data
integration tools.

----------------------------------------------------------------------

SUBMISSION DETAILS

We invite submissions of papers in Springer LNCS style, see

http://www.springer.com/comp/lncs/Authors.html

to arrive no later than January 26th, 2010.

The length of submissions is limited to 11 pages, including title and
abstract (can be omitted if necessary), and list of references.
Papers must be submitted in PDF format via EasyChair; see

http://www.easychair.org/conferences/?conf=dl2010

The workshop proceedings will be made available electronically in the
CEUR Workshop Proceedings series; see

http://www.CEUR-ws.org/

Accepted submissions will be selected for either oral or poster
presentation; however, no distinction will be made in the workshop
proceedings: all accepted papers can be 11 pages long.

----------------------------------------------------------------------

WORKSHOP CHAIRS

* Grant Weddell, Waterloo (Workshop Chair)
* Volker Haarslev, Concordia (PC Chair)
* David Toman, Waterloo (PC Chair)

----------------------------------------------------------------------

RESOURCES

* Information about registration, travel information, accommodation,
and so on will be made available on the DL 2009 homepage:

http://www.cs.uwaterloo.ca/conferences/dl2010/

* Enquiries about the DL 2009 workshop can be made by contacting
the organizing committee:

dl2010@...

* The official Description Logic home page is at

http://dl.kr.org/

----------------------------------------------------------------------

--
Dr. David Toman, Associate Professor
D.R.Cheriton School of Computer Science tel: (519) 888-4567 ext 34447
University of Waterloo fax: (519) 885-1208
200 University Avenue West david@...
Waterloo, Ontario, Canada N2L 3G1 http://db.uwaterloo.ca/~david
_______________________________________________
clean-list mailing list
clean-list@...
http://mailman.science.ru.nl/mailman/listinfo/clean-list

SETP-10 Call for papers

2009-11-10T13:54:03Z

SETP-10 Call for papers

The 2010 International Conference on Software Engineering Theory and Practice (SETP-10) (website: http://www.PromoteResearch.org) will be held during 12-14 of July 2010 in Orlando, FL, USA. SETP is an important event in the areas of Software development, maintenance, and other areas of software engineering and related topics.

The conference will be held at the same time and location where several other major international conferences will be taking place. The conference will be held as part of 2010 multi-conference (MULTICONF-10). MULTICONF-10 will be held during July 12-14, 2010 in Orlando, Florida, USA. The primary goal of MULTICONF is to promote research and developmental activities in computer science, information technology, control engineering, and related fields. Another goal is to promote the dissemination of research to a multidisciplinary audience and to facilitate communication among researchers, developers, practitioners in different fields. The following conferences are planned to be organized as part of MULTICONF-10.

International Conference on Artificial Intelligence and Pattern Recognition (AIPR-10)
International Conference on Automation, Robotics and Control Systems (ARCS-10)
International Conference on Bioinformatics, Computational Biology, Genomics and Chemoinformatics (BCBGC-10)
International Conference on Computer Networks (CN-10)
International Conference on Enterprise Information Systems and Web Technologies (EISWT-10)
International Conference on High Performance Computing Systems (HPCS-10)
International Conference on Information Security and Privacy (ISP-10)
International Conference on Image and Video Processing and Computer Vision (IVPCV-10)
International Conference on Software Engineering Theory and Practice (SETP-10)
International Conference on Theoretical and Mathematical Foundations of Computer Science (TMFCS-10)

We invite draft paper submissions. Please see the website http://www.PromoteResearch.org for more details.

Sincerely

John Edward

Publicity committee

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