Poly/ML April 2013

polyml@lists.polyml.org

22 participants
15 discussions

suppressing compiler output
by gbuday＠gmail.com 18 Apr '13

18 Apr '13

Hi, I would like to feed an sml program into poly from standard input: $ cat hello.sml |poly Poly/ML 5.4.1 Release > # Hello World!val it = (): unit Is it possible to use this so that the compiler itself does not print anything? I have found poly -q which does not print the release message but that still prints all the rest. - Gergely

11 41

The rules of polymorphism
by aleks0＠gmail.com 15 Apr '13

15 Apr '13

This is more of a standard ML question, but I figure folks here will know. I've always found the situations in which poly/ML allows polymorphic values (versus forcing a monotype) a bit puzzling. Take this bit of code, for instance: datatype 'a box = Empty | Box of 'a datatype 'a wrap = Wrap of 'a val box = Box val wrap = Wrap val empty = Empty (* first situation *) val x = Wrap empty (* polymorphic value : 'a box wrap *) val y = wrap empty (* monotype : _a box wrap *) (* second situation *) fun wrapbox1 x = wrap (box x) (* : 'a -> 'a box wrap *) val wrapbox2 = wrap o box (* : _a -> _a box wrap *) In the first situation, its clear that SML treats a type constructor differently than it's associated function, which makes sense. I've always treated the "val foo = Foo" syntax as syntactic sugar for "fun foo x = Foo x". Is this right, or only approximately right? In the second situation, it seems like the expression "val wrapbox2 = wrap o box" is forcing "wrap o box" to be executed "too soon", so the compiler has no choice but to give it a monotype. For instance, changing the expression to "fn () => (wrap o box)" preserves the polymorphism. So, my main question: Is there a reasonable/memorable set of rules for determining when an expression will produce a polymorphic value as opposed to a monotype? Is this written down somewhere (e.g. in the SML 97 spec/commentary)? A second, more specific question: Is there a way for values resulting from a function call to maintain their polymorphism? That is, can I produce a polymorphic empty value of type " 'a box wrap " using just "wrap : 'a -> 'a wrap" and "empty : 'a box"? Where everything is at the top-level, this doesn't seem necessary. However, with a bunch of structures and abstract types around, I've run into this dead end before. Is it possible to get something like "val empty = Foo.mk (Bar.empty, Baz.empty)", with "Bar.empty : 'a bar", and "Baz.empty : 'a baz" and "val empty : ('a bar, 'b baz) foo"? The only solutions I've found are ditching the nice abstract type Foo.T by moving the datatype def to the signature (boo!) or replacing "val empty" with "fun empty () = ..." and needing to write "(empty ())" everywhere (double boo!). Does anyone know a nice way around this?

2 2

suppressing compiler output
by David.Matthews＠prolingua.co.uk 15 Apr '13

15 Apr '13

Alex, I don't know if you intended to send this to the list as well but I'm copying it back there because I think it might be of general interest. While I was playing around with the polyc script I wondered about adding a --usestring option, similar to --use but with the actual ML in there rather than the file name. Similar to the -e option to sed and awk rather than the -f. It would then be possible to include the command to load your saved state on the poly command line. e.g. poly --usestring "PolyML.SaveState.loadState\"$SAVE\";" --use ... Would that work? David On 05/04/2013 13:48, Alex Merry wrote: > On 05/04/13 13:24, David Matthews wrote: >> I've added a "polyc" script that is generated from the build process. >> The idea of this is to provide the similar sort of functionality that >> users of C expect from the "cc" command. It's very simple at the moment >> and is limited to a few options. It compiles an ML source file and >> exports the "main" function. The -o option specifies where the >> executable is to be placed, defaulting to a.out on Unix. > > This sounds really useful. > > One thing I would find useful is an option to load a saved state before > using a file; in Quantomatic, we save the build state, then have some > executables built on top of that (and also have a way of getting a > toplevel with that state). > > Of course, we could just load the state from the file that contains the > main function, but that means either hard-coding the path to the saved > state in those files or having option-parsing boilerplate at the top of > each file to get the path of the saved state. > > Currently, our build scripts have an -l/--load option (the two are > equivalent) to do this. > > Alex >

2 4

Memory Management across multiple threads using Futures Library
by michael.bradley＠hotmail.co.uk 14 Apr '13

14 Apr '13

Dear all, I am experiencing inefficiency while using the Futures library within PolyML. Parallel threads are being forced to 'sleep' for several seconds at a time for no clear reason, and I suspect it may be due to memory management between multiple threads. The test machine has 80GB RAM and 24 available cores. The parallel process works in roughly the same way as the Bag of Tasks Model with Replacements: (I'll refer to the distributor of tasks as the Controller, and other threads as Workers) 1. The Controller constructs an initial list of tasks.2. It sends the tasks to Workers in parallel, distributing across cores appropriately. Tasks are spawned by Future calls. They return a mixture of new tasks and results.3. It synchronises on all of the spawned tasks, organises them and repeats from (2) if any tasks remain. Tasks require a modest amount of memory and significant time to run, but there are 100,000s of them. The memory consumed can rise by 10GB in a few seconds but does not exceed the available RAM, and is held almost entirely by the Controller. The process can take minutes to run, but I see that spawned Futures in the program are required to sleep for the majority (~75%) of the time. The turnover in memory is very high as well, especially in the Controller thread, so calls to the garbage collector can reduce the RAM required dramatically. Initially, as the original problem size grows the speedup via parallelisation rises to a peak of around 6 times, requiring only a few GBs of RAM. However, as the problem size continues to rise and the problem should be easier to parallelise, the speedup falls to the point where a sequential algorithm evaluating tasks one at a time is more efficient. Artificial tests show that when virtually no memory is required, a speedup of over 10 times is quite easy to achieve. What I believe might be causing this is the allocation of segment sizes to threads in the heap. I believe that calls to the common memory pool to change the segment size are causing all threads to sleep unnecessarily. Does each thread currently have its own independent adaptive segment size, or are all threads required to use the same segment size? Do all threads have to pause if one segment size is being changed? I have timed the synchronisation phase above and it requires 10-100s of microseconds typically, so not accounting for the regular sleep times of several seconds. I know the threads are being paused mid-task computation, and I have tried increasing the heap size as well to no effect. Does anyone know what might be causing this behaviour?Best regards,Michael

4 5

Final CfP (extension): Trends in Functional Programming 2013
by jay.mccarthy＠gmail.com 03 Apr '13

03 Apr '13

FINAL CALL FOR PAPERS (DEADLINE EXTENSION) 14th International Symposium Trends in Functional Programming 2013 Brigham Young University, Utah, U.S.A. May 14-16, 2013 http://faculty.cs.byu.edu/~jay/conferences/2013-tfp/ [The deadline has been extended two weeks from April 2nd to April 16th.] The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. It aspires to be a lively environment for presenting the latest research results, and other contributions (see below), described in draft papers submitted prior to the symposium. A formal post-symposium refereeing process then selects a subset of the articles presented at the symposium and submitted for formal publication. Selected papers will be published as a Springer Lecture Notes in Computer Science (LNCS: http://www.springer.com/lncs) volume. TFP 2013 will be the main event of a pair of functional programming events at Brigham Young University. First will be the International Workshop on Trends in Functional Programming in Education and then TFP. The TFP symposium is the heir of the successful series of Scottish Functional Programming Workshops. Previous TFP symposia were held in Edinburgh (Scotland) in 2003, in Munich (Germany) in 2004, in Tallinn (Estonia) in 2005, in Nottingham (UK) in 2006, in New York (USA) in 2007, in Nijmegen (The Netherlands) in 2008, in Komarno (Slovakia) in 2009, in Oklahoma (USA) in 2010, in Madrid (Spain) in 2011, and in St. Andrews (UK) in 2012. For further general information about TFP please see the TFP homepage at http://www.tifp.org/. SCOPE OF THE SYMPOSIUM The symposium recognises that new trends may arise through various routes. As part of the symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research Articles: leading-edge, previously unpublished research work Position Articles: on what new trends should or should not be Project Articles: descriptions of recently started new projects Evaluation Articles: what lessons can be drawn from a finished project Overview Articles: summarising work with respect to a trendy subject Articles must be original and not submitted for simultaneous publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or more experience oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Articles on the following subject areas are particularly welcome: . Functional programming and multicore/manycore computing . Functional programming in the cloud . Functional programming in education . High performance functional computing . Extra-functional (behavioural) properties of functional programs . Dependently typed functional programming . Validation and verification of functional programs . Using functional techniques to verify/reason about imperative/object-oriented programs . Debugging for functional languages . Functional programming in different application areas: security, mobility, telecommunications applications, embedded systems, global computing, grids, etc. . Interoperability with imperative programming languages . Novel memory management techniques . Program transformation techniques . Empirical performance studies . Abstract/virtual machines and compilers for functional languages . New implementation strategies . Any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2013 program chair, Jay McCarthy, at tfp2013 at easychair.org BEST STUDENT PAPER AWARD TFP traditionally pays special attention to research students, acknowledging that students are almost by definition part of new subject trends. A student paper is one for which the authors state that the paper is mainly the work of students, the students are listed as first authors, and a student would present the paper. A prize for the best student paper is awarded each year. SUBMISSION AND DRAFT PROCEEDINGS Acceptance of papers for presentation at the symposium is based on a lightweight screening process of extended abstracts (2 to 10 pages in length) or full papers (max 16 pages). Accepted abstracts are to be completed to full papers before the symposium for publication in the draft proceedings. Latex style files are available from Springer's web page (llncs2e.zip), and are linked below. The submission must clearly indicate which category it belongs to: research, position, project, evaluation, or overview paper. It should also indicate whether the main author or authors are research students. Formatting details can be found at the TFP 2013 website. Paper submission is done through TFP13's EasyChair page: https://www.easychair.org/conferences/?conf=tfp2013 Important dates (2013): Full papers/extended abstracts submission: March 2nd to April 16th, 2013 (extended) Notification of acceptance for presentation: Submission + one week Early registration deadline: Tuesday, April 16th, 2013 Late registration deadline: Tuesday, May 14th, 2013 Camera ready for draft proceeding: Tuesday, May 7th, 2013 (extended) The papers of the local proceedings will also be made available on-line under some copyright conditions, with which all authors are asked to agree. POST-SYMPOSIUM REFEREEING AND PUBLICATION In addition to the symposium draft proceedings, we will continue the previous years' decision of publishing a high-quality subset of contributions in the Springer Lecture Notes in Computer Science (LNCS) series. Proceedings of the last three instances of TFP have been published as LNCS 6546 (TFP10), LNCS 7193 (TFP11), and LNCS TBA (TFP12). All TFP authors will be invited to submit revised papers after the symposium. These will be refereed using normal conference standards and a subset of the submitted papers, over all categories, will be selected for publication. Papers will be judged on their contribution to the research area with appropriate criteria applied to each category of paper. Student papers will be given extra feedback by the Program Committee in order to assist those unfamiliar with the publication process and to help in improving the quality of the paper. Important dates (2013): TFP 2013 Symposium: Tuesday, May 14th, 2013 -- Thursday May 16, 2013 Student papers feedback: Friday, May 24th, 2013 Submission for formal review: Friday, June 21st, 2013 Notification of acceptance for LNCS: Friday, August 30th, 2013 Camera ready paper: Friday, September 27th, 2013 REGISTRATION Registration for TFP13, as well as the adjoined workshops, is handled through the on-line registration page below. Note that for guaranteed on-site accommodation, registration must be completed by the early registration deadline. http://ce.byu.edu/cw/tfp/ TFP 2013 ORGANIZATION Steering Committee Chair: Marko van Eekelen, Radboud University Nijmegen and Open University, NL Steering Committee Treasurer: Hans-Wolfgang Loidl, Heriot-Watt University, UK Steering Committee Secretary: Marco T. Moraz?n, Seton Hall University, New Jersey, U.S.A. Symposium Organization Chair: Jay McCarthy, Brigham Young University, Utah, U.S.A Local Arrangements: Jay McCarthy, Brigham Young University, Utah, U.S.A TFP 2013 PROGRAMME COMMITTEE Chair: Jay McCarthy from Brigham Young University Andy Gill from the University of Kansas Arjun Guha from Cornell University Clara Segura from Complutense University of Madrid Henrik Nilsson from University of Nottingham James Caldwell from the University of Wyoming John Clements from California Polytechnic State University Jurriaan Hage from Universiteit Utrecht Keiko Nakata from Institute of Cybernetics at Tallinn University of Technology Marko van Eekelen from Open University of the Netherlands and Radboud University Nijmegen Nikhil Swamy from Microsoft Research Rita Loogen from Philipps-Universit?t Marburg Sergio Antoy from Portland State University Suresh Jagannathan from Purdue University Tom Schrijvers from Ghent University Vikt?ria Zs?k from E?tv?s Lor?nd University, Budapest Wolfgang De Meuter from Vrije Universiteit Brussel SPONSORS TFP 2013 is sponsored by the Brigham Young University Computer Science department. INVITED SPEAKER In this instance of TFP, an invited talk will be given by Jeremy Siek, Assistant Professor at University of Colorado at Boulder. Prof Siek will be talking on the gradual typing approach to mixing static and dynamic typing. LINKS Main TFP13 page: http://faculty.cs.byu.edu/~jay/conferences/2013-tfp/ TFP home page: http://www.tifp.org/ Submission page: https://www.easychair.org/conferences/?conf=tfp2013 Latex style files: ftp://ftp.springer.de/pub/tex/latex/llncs/latex2e/llncs2e.zip Registration page: http://ce.byu.edu/cw/tfp/ -- Jay McCarthy <jay(a)cs.byu.edu> Assistant Professor / Brigham Young University http://faculty.cs.byu.edu/~jay "The glory of God is Intelligence" - D&C 93

1 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

Poly/ML April 2013