October 2024 - Haskell-Cafe

Call for Proposals Now Open for Functional Conf 2025 (online)
by John Sinclair 17 Oct '24

17 Oct '24

Attention all functional programming enthusiasts and experts! The Functional Conf 2025 Call for Proposals is now open, and it's a golden opportunity to share your insights and innovative applications of functional programming with a vibrant community of like-minded individuals. Whether you have tackled a tricky problem using functional programming, developed a unique application, or have experiences that could enlighten your peers, we want to hear from you! We're open to all topics related to functional programming. We are seeking deep technical topics that push the boundaries of what's possible with functional programming. Our commitment to diversity and transparency means all proposals will be public for community review. Is your proposal unique? Is it well-developed and ready-to-go? Then you've got what it takes! Submit your ideas and help us make Functional Conf 2025 an unforgettable experience. Submit your proposal today and help shape the future of functional programming! https://confengine.com/conferences/functional-conf-2025/proposals<https://confengine.com/conferences/functional-conf-2025/proposals?utm_mediu…> Submission deadline: 17 November 2024 Functional Conf is an online event running 24-25 January 2025. Learn more about the conference: https://functionalconf.com

1 0

POPL 2025 Call for Tutorials (deadline extended: Oct 25th, 2024)
by Ningning Xie 17 Oct '24

17 Oct '24

POPL 2025 CALL FOR TUTORIALS https://popl25.sigplan.org/track/POPL-2025-tutorials#Call-For-Tutorials The 52nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL 2025) will be held in Denver, United States. POPL provides 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. Tutorials for POPL 2025 are solicited on any topic relevant to the POPL community. We particularly encourage submissions of introductory tutorials that make the research presented at POPL more accessible to the participants. Tutorials will be held on Jan 19–21, 2025. The expected length of a tutorial is 3 hours, including questions and discussion (Q&A). *Submission details* Deadline for submission:* October 25th, 2024* Notification of acceptance: November 1st, 2024 A tutorial proposal should provide the following information: - Tutorial title - Presenter(s), affiliation(s), and contact information - 1-3 page description (for evaluation). This should include the objectives, topics to be covered, presentation approach, target audience, prerequisite knowledge, and if the tutorial was previously held, the location (i.e. which conference), date, and number of attendees if available. - 1-2 paragraph abstract suitable for tutorial publicity. - 1-paragraph biography suitable for tutorial publicity. Proposals must be submitted by email to Christoph Matheja (chmat(a)dtu.dk) and Robert Rand (rand(a)uchicago.edu) with the subject line "POPL 2025 Tutorial Proposal: [tutorial name]". The proposal should be attached as a PDF, docx, or txt file. *Further information* Any query regarding POPL 2025 tutorial proposals should be addressed to the co-located events chairs Christoph Matheja (chmat(a)dtu.dk) and Robert Rand ( rand(a)uchicago.edu) or to the general chair Steve Zdancewic ( stevez(a)seas.upenn.edu)

1 0

Re: [Haskell-cafe] [ANNOUNCE] GHC 9.12.1-alpha1 is now available
by Vanessa McHale 16 Oct '24

16 Oct '24

2 1

anyone using wxHaskell
by Zoran Bošnjak 15 Oct '24

15 Oct '24

Dear haskell cafe, I have a problem with scrolledWindow inside notebook, when running with the latest version of wxHaskell. See the minimal example below, where the scrollbar is not shown (the same sample is OK on the wxHaskell version from few years ago). I would appreciate a suggestion how to make the scrollbar work again (a workaround if possible). I have also filed the issue on the wxHaskell project page. But the project does not look like being super actively maintained. https://codeberg.org/wxHaskell/wxHaskell/issues/48 Minimal example: module Main where import Graphics.UI.WXCore import Graphics.UI.WX gui :: IO () gui = do f <- frame [text := "Frame"] p <- panel f [] nb <- notebook p [] p1 <- scrolledWindow nb [ scrollRate := sz 20 20 ] texts <- mapM (\n -> staticText p1 [text := ("test" <> show n) ]) [1::Int ..20] set f [ layout := fill $ widget p , clientSize := sz 400 200 ] set p [ layout := fill $ tabs nb [ tab "tab1" $ container p1 $ column 5 (fmap widget texts) ] ] main :: IO () main = start gui regards, Zoran

3 7

Re: [Haskell-cafe] Runtime selection on types while capturing a dictionary?
by Benjamin Redelings 14 Oct '24

14 Oct '24

On 10/9/24 10:11 AM, Benjamin Redelings wrote: > Interesting! And thanks. I've been able to move the labels into the > Graph class, and just use () as the label type when I don't want > labels. Somehow I was expecting a Haskell mailing list to recommend > something involving DataKinds. > > The other augmentations are a bit more tricky. The tree can have > either a BranchLength augmentation OR a NodeTime augmentation, but not > both. The NodeTime augmentation only makes sense when the tree is > rooted. Additionally, it makes sense on rooted forests and directed > acyclic graphs. When using the NodeTime augmentation, we can > CALCULATE the branch lengths as the time difference between the nodes > at the two ends of a branch. This provides some motivation to make > the branchLength function polymorphic, so that some of the downstream > code can be agnostic as to whether the branch lengths are directly > augmented, or computed from NodeTimes. And then there is also a > BranchRate augmentation that only makes sense if we have a NodeTime > augmentation. > > I think your ADT makes more sense than just creating a lot of > (AddAugmentationX ExtraInfo Graph) data types. So, I'll have to think > how to do that. > > On the other hand, I would like to retain some polymorphism. For > example, it would be nice to allow multiple tree representations. > Sometimes a generic graph is what you want, but in other cases the > tree-generation process makes a data structure like > > data Tree = Leaf {parent :: Maybe Tree } | Internal { left:: Tree, > right:: Tree, parent:: (Maybe Tree)} > > more natural. So, having an IsGraph *class* versus just a single > Graph data structure seems valuable. > > QUESTION: Given that, can you expand on what counts as a type-class > "shenanigan"? I fully agree that the class structure and the data > type structure isn't very good yet. (It was implemented in haste to > make something "just work". The standard format for printing trees -- > Newick format -- really prints rooted trees, so I ended up creating a > 'type family Rooted t' to make a rooted tree type from an unrooted > tree type. That seems very hacky.) But I would like to retain some > generality across common features between NodeTime and BranchLength > augmented trees, as well as (perhaps) generality across different > implementations of Graph / Tree. > > QUESTION: For the constraint that a NodeTime tree should be rooted, do > you think I should encode this constraint at the data-type level, or > at the function level? I was initially thinking of encoding this at > the data type level, so that you couldn't construct a tree with node > times that was not rooted. But I suppose one could simply make all the > functions that USE node-time trees require some kind of Rooted > constraint by calling a function like 'parent node'. This would > decouple the Rooted/Unrooted augmentation from the BranchLength / > NodeTime / Nothing augmentation. Thoughts? > > -BenRI > > > On 10/7/24 6:13 PM, Tom Ellis wrote: >> On Mon, Oct 07, 2024 at 05:38:30PM -0400, Benjamin Redelings wrote: >>> I'm new to Haskell, and I'm writing a class for evolutionary trees. >>> Since >>> I'm new to Haskell, trying to encode information at the type level >>> is new to >>> me. In C++ I'd use runtime checks to ask whether (for example) a >>> tree is >>> rooted. Or I'd have the getRoot function return Maybe NodeID and >>> then make >>> the methods for checking if a branch points rootward throw an >>> exception if >>> the tree is unrooted. >> I think I'd just do >> >> data AugmentedTree roots lengths labels = >> MkAugmentedTree { >> tree :: Tree, >> labels :: labels, >> roots :: roots, >> lengths :: lenghts >> } >> >> and then just do stuff like >> >> type FullyAugmentedTree = >> AugmentedTree [NodeId] (IntMap Double) (IntMap (Maybe l)) >> type PartiallyAugmentedTree = >> AugmentedTree [NodeId] () (IntMap (Maybe l)) >> >> For rootedness-independence I strongly recommend against any type >> class shenanigans. Instead you can do >> >> data PossiblyRootedTree lengths labels where >> RootedTree :: AugmentedTree [NodeId] lengths labels >> UnrootedTree :: AugmentedTree () lengths labels >> >> and then >> >> isRooted :: PossiblyRootedTree lengths labels -> Bool >> isRooted = \case >> RootedTree {} -> True >> UnrootedTree {} -> False >> >> (but `isRooted` is not really very useful compared to just pattern >> matching every where you need to know.) >> >> Tom >> _______________________________________________ >> Haskell-Cafe mailing list >> To (un)subscribe, modify options or view archives go to: >> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >> Only members subscribed via the mailman list are allowed to post.

2 1

Call for Contributions: BOB 2025 (Berlin, March 14 - Deadline Nov 15)
by Stefan Wehr 14 Oct '24

14 Oct '24

================================================================================ BOB Conference 2025 "What happens when we use what's best for a change?" https://bobkonf.de/2025/cfc.html Berlin, Mar 14 Call for Contributions Deadline: November 15, 2024 ================================================================================ You are actively engaged in advanced software engineering methods, solve ambitious problem with software and are open to cutting-edge innovation? Attend this conference, meet people that share your goals, and get to know the best software tools and technologies available today. We strive to offer a day full of new experiences and impressions that you can use to immediately improve your daily life as a software developer. If you share our vision and want to contribute, submit a proposal for a talk or tutorial! NOTE: The conference fee will be waived for presenters. Travel expenses will not be covered (for exceptions see "Speaker Grants"). Shepherding ----------- The program committee offers shepherding to all speakers. Shepherding provides speakers assistance with preparing their sessions. Specifically: - advice on structure and presentation - review of talk slides Speaker Grants -------------- BOB has Speaker Grants available to support speakers from groups under-represented in technology. We specifically seek women speakers, speakers of color, and speakers who are not able to attend the conference for financial reasons. Topics ------ We are looking for talks about best-of-breed software technology, e.g.: - functional programming - persistent data structures and databases - event-based modelling and architecture - "fancy types" (dependent types, gradual typing, linear types, ...) - formal methods for correctness and robustness - abstractions for concurrency and parallelism - metaprogramming - probabilistic programming - math and programming - controlled side effects - program synthesis - next-generation IDEs - effective abstractions for data analytics - … everything really that isn’t mainstream, but you think should be - … includeing rough ideas worth discussing. Presenters should provide the audience with information that is practically useful for software developers. Challenges ---------- Furthermore, we seek contributions on successful approaches for solving hard problems, for example: - bias in machine-learning systems - digital transformation in difficult settings - accessibiltity - systems with critical reliability requirements - ecologically sustainable software development We're especially interested in experience reports. Other topics are also relevant, e.g.: - introductory talks on technical background - overviews of a given field - demos and how-tos Requirements ------------ We accept proposals for presentations of 45 minutes (40 minutes talk + 5 minutes questions), as well as 90 minute tutorials for beginners. The language of presentation should be either English or German. Your proposal should include (in your presentation language of choice): - An abstract of max. 1500 characters. - A short bio/cv - Contact information (including at least email address) - A list of 3-5 concrete ideas of how your work can be applied in a developer's daily life - additional material (websites, blogs, slides, videos of past presentations, …) Organisation ------------ - Direct questions to konferenz at bobkonf dot de - Proposal deadline: November 15, 2024 - Notification: December 4, 2024 - Program: December 11, 2024 Submit here: https://pretalx.com/bob-2025/submit/ Program Committee ----------------- (more information here: https://bobkonf.de/2025/programmkomitee.html) - Matthias Fischmann, Wire - Matthias Neubauer, SICK AG - Nicole Rauch, Softwareentwicklung und Entwicklungscoaching - Michael Sperber, Active Group - Stefan Wehr, Hochschule Offenburg Scientific Advisory Board - Annette Bieniusa, TU Kaiserslautern - Torsten Grust, Uni Tübingen - Peter Thiemann, Uni Freiburg

1 0

Ideas for a master's thesis
by Jon Kristensen 11 Oct '24

11 Oct '24

Hi! I'm about to do a master's thesis in Software Engineering and I'm thinking about the possibility of doing something related to Haskell. I would like to apply (Bayesian) statistics and, ideally, conduct some kind of experiment. If you have any suggestions on topics, please let me know! Are there perhaps any particular challenges related to packages, dependencies, breakages or security vulnerabilities that I could take a look at? Is the PVP debate still ongoing, by the way? Back in 2016, when I started looking into what I could do as a thesis, I wrote the following in a thesis proposal: There is a (polarized) debate in the Haskell community about its package versioning policy (“PVP”), a variant of semantic versioning. Basically, the debate is centered around whether developers of Haskell packages should be “optimistic” or “pessimistic” in regards to breakages when introducing new versions of dependencies. Put differently, the debate is about how liberal or conservative developers should be when they set upper bound version restrictions for dependencies that have not been released yet. A liberal approach can result in a late discovery of a package breaking (possibly during compilation), and a conservative approach could result in constraints that cause the dependency solver not to find a set of dependencies that satisfies the version constraints (where one would have been possible and desirable). The objective for the study is to inform the PVP debate by developing a model that can be used to analyze why packages break when new versions of dependencies are released. The research question is: How can the handling of package dependencies in package systems using semantic versioning be changed to significantly reduce the problem of packages breaking? Thanks! 🙂 All the best, Jon

2 1

[TFP 2025 2nd Call for Papers] 25th International Symposium on Trends in Functional Programming (Oxford, UK)
by Peter Achten 11 Oct '24

11 Oct '24

# TFP 2025 - 2nd Call for Papers (trendsfp.github.io) 26th International Symposium on Trends in Functional Programming 14-16 January 2025, Oxford, UK ## Important Dates Submission deadline (pre-symposium, full papers): Wed 13th Nov 2024 (AOE) Notification (pre-symposium, full papers): Wed 11th Dec 2024 Submission deadline (pre-symposium draft papers): Wed 11th Dec 2024 (AOE) Notification (pre-symposium draft papers): Mon 16th Dec 2024 Submission deadline (post-symposium review): Wed 19th Feb 2025 (AOE) Notification (post-symposium submissions): Wed 26th Mar 2025 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. This year, TFP will take place in-person at the University of Oxford, UK. It is co-located with the Trends in Functional Programming in Education (TFPIE) workshop, which will take on the day before the main symposium. Please be aware that TFP has several submission deadlines. The first, 13th November, is for authors who wish to have their full paper reviewed prior to the symposium. Papers that are accepted in this way must also be presented at the symposium. The second, 11th December, is for authors who wish to present their work or work-in-progress at the symposium first without submitting to the full review process for publication. These authors can then take into account feedback received at the symposium and submit a full paper for review by the third deadline, 19th February. ## Scope The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five paper categories. High-quality submissions are solicited in any of these categories: * Research Papers: Leading-edge, previously unpublished research work * Position Papers: On what new trends should or should not be * Project Papers: Descriptions of recently started new projects * Evaluation Papers: What lessons can be drawn from a finished project * Overview Papers: Summarizing work with respect to a trendy subject Papers must be original and not simultaneously submitted for publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Topics suitable for the symposium include, but are not limited to: * Functional programming and multicore/manycore computing * Functional programming in the cloud * High performance functional computing * Extra-functional (behavioural) properties of functional programs * Dependently typed functional programming * Validation and verification of functional programs * Debugging and profiling 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 analysis and transformation techniques * Empirical performance studies * Abstract/virtual machines and compilers for functional languages * (Embedded) domain specific languages * New implementation strategies * Any new emerging trend in the functional programming area If you are in doubt on whether your paper is within the scope of TFP, please contact the programme chair, Jeremy Gibbons. ## Best Paper Awards TFP awards two prizes for the best papers each year. First, to reward excellent contributions, TFP awards a prize for the best overall paper accepted for the post-conference formal proceedings. Second, each year TFP also awards a prize for the best student paper. 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 the paper's first authors, and a student would present the paper. In both cases, it is the PC of TFP that awards the prize. In case the best paper happens to be a student paper, then that paper will receive both prizes. ## Instructions to Authors Submission is via EquinOCS (https://equinocs.springernature.com/service/tfp2025) Authors of papers have the choice of having their contributions formally reviewed either before or after the Symposium. Further, pre-symposium submissions may either be full (earlier deadline) or draft papers (later deadline). ## Pre-symposium formal review Papers to be formally reviewed before the symposium should be submitted before the early deadline and will receive their reviews and notification of acceptance for both presentation and publication before the symposium. A paper that has been rejected for publication but accepted for presentation may be revised and resubmitted for the post-symposium formal review. ## Post-symposium formal review Draft papers will receive minimal reviews and notification of acceptance for presentation at the symposium. Authors of draft papers will be invited to submit revised papers based on the feedback received at the symposium. A post-symposium refereeing process will then select a subset of these papers for formal publication. ## Paper categories Draft papers and papers submitted for formal review are submitted as extended abstracts (4 to 10 pages in length) or full papers (up to 20 pages). The submission must clearly indicate which category it belongs to: research, position, project, evaluation, or overview paper. It should also indicate which authors are research students, and whether the main author(s) are students. A draft paper for which all authors are students will receive additional feedback by one of the PC members shortly after the symposium has taken place. ## Format Papers must be written in English, and written using the LNCS style. For more information about formatting please consult the Springer LNCS Guidelines web site (https://www.springer.com/gp/computer-science/lncs/conference-proceedings-gu…) ## Organizing Committee Jeremy Gibbons University of Oxford, UK Programme Chair Jason Hemann Seton Hall University, US Conference Chair Peter Achten Radboud University Nijmegen, NL Publicity Chair Marco T. Morazán Seton Hall University, US Steering Committee Chair ## Programme Committee Peter Achten Radboud University Nijmegen, NL Edwin Brady University of St Andrews, UK Laura Castro University of A Coruña, ES Youyou Cong Tokyo Institute of Technology, JP Paul Downen University of Massachusetts Lowell, US João Paulo Fernandes University of Coimbra, PT Ben Greenman University of Utah, US Jurriaan Hage Heriot-Watt University, UK Jason Hemann Seton Hall University, US Zhenjiang Hu Peking University, CN Hans-Wolfgang Loidl Heriot-Watt University, UK Kazutaka Matsuda Tohoku University, JP Zoe Paraskevopoulou Ethereum Foundation, US Alejandro Serrano 47 Degrees, ES Nick Smallbone Chalmers University, SE Alley Stoughton Boston University, US Wouter Swierstra Utrecht University, NL Niki Vazou IMDEA Software Institute, ES Marcos Viera Universidad de la República, UY Viktória Zsók Eötvös Loránd University of Sciences, HU

1 0

1st CfP: SLE 2025 - 18th ACM SIGPLAN International Conference on Software Language Engineering
by Andrei Chis 10 Oct '24

10 Oct '24

18th ACM SIGPLAN International Conference on Software Language Engineering (SLE 2025) 12-13 June 2025 Koblenz, Germany https://www.sleconf.org/2025/ https://x.com/sleconf ------------------------------------------------------------------------ We are pleased to invite you to submit papers to the 18th ACM SIGPLAN International Conference on Software Language Engineering (SLE) which is devoted to the principles of software languages: their design, their implementation, and their evolution. The SLE 2025 conference will be co-located with STAF 2025 and hosted in Koblenz, Germany, on 12-13 June 2025. --------------------------- Important Dates --------------------------- * Abstract submission: Fri 7 Feb 2025 * Paper submission: Fri 14 Feb 2025 * Authors response period: Tue 1 Apr - Sat 5 Apr 2025 * Notification: Tue 15 Apr 2025 * Conference: Thu 12 June - Fri 13 June 2025 (co-located with STAF) All dates are Anywhere on Earth. --------------------------- Topics of Interest --------------------------- SLE covers software language engineering in general, rather than engineering a specific software language. Topics of interest include, but are not limited to: * Software Language Design and Implementation - Approaches to and methods for language design - Static semantics (e.g., design rules, well-formedness constraints) - Techniques for specifying behavioral/executable semantics - Generative approaches (incl. code synthesis, compilation) - Meta-languages, meta-tools, language workbenches - AI-assisted language design and optimisation * Software Language Validation - Verification and formal methods for languages - Testing techniques for languages - Simulation techniques for languages - Model-based testing - AI-assisted validation * Software Language Integration and Composition - Coordination of heterogeneous languages and tools - Mappings between languages (incl. transformation languages) - Traceability between languages - Deployment of languages to different platforms - AI-assisted refactoring * Software Language Maintenance - Software language reuse - Language evolution - Language families and variability, language and software product lines * Domain-specific approaches for any aspects of SLE (design, implementation, validation, maintenance) * Empirical evaluation and experience reports of language engineering tools - User studies evaluating usability - Performance benchmarks - Industrial applications * Synergies between Language Engineering and emerging/promising research areas - Generative AI in language engineering (e.g., AI-based language modelling, AI-driven code generation tools) - AI and ML language engineering (e.g., ML compiler testing, code classification) - Quantum language engineering (e.g., language design for quantum machines) - Language engineering for physical systems (e.g., CPS, IoT, digital twins) - Socio-technical systems and language engineering (e.g., language evolution to adapt to social requirements) --------------------------- Types of Submissions --------------------------- SLE accepts the following types of papers: * Research papers: These are “traditional” papers detailing research contributions to SLE. Papers may range from 6 to 12 pages in length and may optionally include 2 further pages of bibliography/appendices. Papers will be reviewed with an understanding that some results do not need 12 full pages and may be fully described in fewer pages. * New ideas/vision papers: These papers may describe new, unconventional software language engineering research positions or approaches that depart from standard practice. They can describe well-defined research ideas that are at an early stage of investigation. They could also provide new evidence to challenge common wisdom, present new unifying theories about existing SLE research that provides novel insight or that can lead to the development of new technologies or approaches, or apply SLE technology to radically new application areas. New ideas/vision papers must not exceed 5 pages and may optionally include 1 further page of bibliography/appendices. * SLE Body of Knowledge: The SLE Body of Knowledge (SLEBoK) is a community-wide effort to provide a unique and comprehensive description of the concepts, best practices, tools, and methods developed by the SLE community. In this respect, the SLE conference will accept surveys, essays, open challenges, empirical observations, and case study papers on the SLE topics. These can focus on, but are not limited to, methods, techniques, best practices, and teaching approaches. Papers in this category can have up to 20 pages, including bibliography/appendices. * Tool papers: These papers focus on the tooling aspects often forgotten or neglected in research papers. A good tool paper focuses on practical insights that will likely be useful to other implementers or users in the future. Any of the SLE topics of interest are appropriate areas for tool demonstrations. Submissions must not exceed 5 pages and may optionally include 1 further page of bibliography/appendices. They may optionally include an appendix with a demo outline/screenshots and/or a short video/screencast illustrating the tool. Workshops: Workshops will be organised by STAF. Please inform us and contact STAF 2025 organisers if you would like to organise a workshop of interest to the SLE audience. Information on how to submit workshops can be found on the STAF 2025 Website. --------------------------- Submission --------------------------- SLE 2025 has a single submission round for papers, including a mandatory abstract registration and a rebuttal phase, where all authors of research papers will have the possibility of responding to the reviews on their submissions. Authors of accepted research papers will be invited to submit artefacts. --------------------------- Format --------------------------- Submissions have to use the ACM SIGPLAN Conference Format “acmart” ( https://sigplan.org/Resources/Author/#acmart-format) please make sure that you always use the latest ACM SIGPLAN acmart LaTeX template, and that the document class definition is `\documentclass[sigplan,anonymous,review]{acmart}`. Do not make any changes to this format! Ensure that your submission is legible when printed on a black and white printer. In particular, please check that colours remain distinct and font sizes in figures and tables are legible. To increase fairness in reviewing, a double-blind review process has become standard across SIGPLAN conferences. Accordingly, SLE will follow the double-blind process. Author names and institutions must be omitted from submitted papers, and references to the authors’ own related work should be in the third person. No other changes are necessary, and authors will not be penalized if reviewers are able to infer their identities in implicit ways. All submissions must be in PDF format. The submission website is: https://sle25.hotcrp.com --------------------------- Concurrent Submissions --------------------------- Papers must describe unpublished work that is not currently submitted for publication elsewhere as described by SIGPLAN’s Republication Policy ( https://www.sigplan.org/Resources/Policies/Republication/) Submitters should also be aware of ACM’s Policy and Procedures on Plagiarism ( https://www.acm.org/publications/policies/plagiarism-overview) Submissions that violate these policies will be desk-rejected. --------------------------- Policy on Human Participant and Subject Research --------------------------- Authors conducting research involving human participants and subjects must ensure that their research complies with their local governing laws and regulations and the ACM’s general principles, as stated in the ACM’s Publications Policy on Research Involving Human Participants and Subjects ( https://www.acm.org/publications/policies/research-involving-human-particip…) If submissions are found to be violating this policy, they will be rejected. --------------------------- Reviewing Process --------------------------- All submitted papers will be reviewed by at least three members of the program committee. Research papers and tool papers will be evaluated concerning soundness, relevance, novelty, presentation, and replicability. New ideas/vision papers will be evaluated primarily concerning soundness, relevance, novelty, and presentation. SLEBoK papers will be reviewed on their soundness, relevance, originality, and presentation. Tool papers will be evaluated concerning relevance, presentation, and replicability. For fairness reasons, all submitted papers must conform to the above instructions. Submissions that violate these instructions may be rejected without review at the discretion of the PC chairs. For research papers, authors will get a chance to respond to the reviews before a final decision is made. --------------------------- Artefact Evaluation --------------------------- SLE will use an evaluation process to assess the quality of artefacts on which papers are based to foster the culture of experimental reproducibility. Authors of accepted research papers are invited to submit artefacts. --------------------------- Awards --------------------------- * Distinguished paper: Award for the most notable paper, as determined by the PC chairs based on the recommendations of the program committee. * Distinguished artefact: Award for the artefact most significantly exceeding expectations, as determined by the AEC chairs based on the recommendations of the artefact evaluation committee. * Distinguished reviewer: Award for the programme committee member that produced the most useful reviews as assessed by paper authors. * Most Influential Paper: Award for the SLE 2015 paper with the greatest impact, as judged by the SLE Steering Committee. --------------------------- Publication --------------------------- All accepted papers will be published in the ACM Digital Library. **AUTHORS TAKE NOTE**: The official publication date is the date the proceedings are made available in the ACM Digital Library. This date may be up to two weeks prior to the first day of the conference. The official publication date affects the deadline for any patent filings related to published work. --------------------------- Organisation --------------------------- * General chair: Görel Hedin, Lunds Universitet, Sweden * PC co-chair: Regina Hebig, Universität Rostock, Germany * PC co-chair: Vadim Zaytsev, Universiteit Twente, The Netherlands * Publicity chair: Andrei Chiş, feenk gmbh, Switzerland * Local chair: Ralf Lämmel, Universität Koblenz, Germany --------------------------- Contact --------------------------- For additional information, clarification, or answers to any questions, please get in touch with the program co-chairs (regina.hebig(a)uni-rostock.de and vadim(a)grammarware.net)

1 0

Runtime selection on types while capturing a dictionary?
by Benjamin Redelings 09 Oct '24

09 Oct '24

Hi, I'm new to Haskell, and I'm writing a class for evolutionary trees. Since I'm new to Haskell, trying to encode information at the type level is new to me. In C++ I'd use runtime checks to ask whether (for example) a tree is rooted. Or I'd have the getRoot function return Maybe NodeID and then make the methods for checking if a branch points rootward throw an exception if the tree is unrooted. I'm trying to avoid doing this the C++ way, but this raises a lot of question. Let me start with 2 of them: 1. Is there any advice on how to represent data structures that may or may not have a list of attributes? But what I have in Haskell right now looks like this: data Graph (IntMap Node) (IntMap Edge) data WithBranchLengths t = WithBranchLengths t (IntMap Double) data WithLabels t l = WithLabels t (IntMap (Maybe l)) data Forest = Forest Graph {- Assert that the Graph is a Forest -} data WithRoots t = WithRoots t [NodeId] data WithNodeTimes t = WithNodeTimes t (IntMap Double) data WithBranchRates t = WithBranchRates t (IntMap Double) data Tree = Tree Forest {- Assert that the Forest is a Tree -} A tree with labels, roots, and branch lengths could have following types: WithLabels (WithRoots (WithBranchLengths Tree)) Text WithLabels (WithBranchLengths (WithRoots Tree)) Text WithRoots (WithLabels (WithBranchLengths Tree) Text) WithRoots (WithBranchLengths (WithLabels Tree Text)) .. etc etc.. The fact that there are multiple ways to represent the same thing is already not great. Also, the fact that you can do WithBranchLengths (WithBranchLengths Tree) indicates that the construction of types should be obeying certain rules that are not expressed. Only the outer WithBranchLengths is going to count, and there really should not be two of the same attribute. 2. I'm wondering if it is possible to do run-time selection on whether a tree is rooted or not. (I've considered trying to move all checks to the type-level, but this inhibits putting models with different properties into the same list -- see below) class IsGraph g where ... class IsGraph g => IsDirectedGraph g where isForward :: g -> EdgeId -> Bool class IsDirectedGraph g => IsDirectedAcyclicGraph g class IsGraph f => IsForest f where type family Unrooted f type family Rooted f unroot :: f -> Unrooted f makeRooted :: f -> Rooted f class (IsDirectedAcyclicGraph t, IsForest t) => HasRoots t where isRoot :: t -> NodeId -> Bool roots :: t -> [NodeId] isRoot f n = isSource f n roots f = filter (isRoot f) (getNodes f) At first I was thinking that since rooting is at the type level, then I can't do any runtime branching on whether a tree is rooted. But then it occured to me that a GADT can package dictionaries with a constructor, so that in theory I could do something like: likelihood s t = if isEquilibriumReversible s then equilibriumReversibleLikelihood s t else case isRooted t of Unrooted -> error "tree must be rooted, since model is not reversible or not at equilibrium!" Rooted -> rootedTreeLikelihood s t It seems like this might work if I could make a GADT with a signature something like: data MaybeRooted t = Unrooted | HasRoots t => Rooted -- Q: should this use a forall type? In that case the Rooted constructor would package the HasRoots t dictionary needed to run the rootedTreeLikelihood function. But I'm not sure how I would actually write the `isRooted` function that would construct the MaybeRooted t data type. I've considered trying to encode the EquilibriumReversible predicate at the type level to avoid runtime checks, but that has the problem that I couldn't put models with different properties into the the same list of type [m]. So I guess the questions are: Q2a: is this a reasonable way of trying to do runtime selection on whether a tree is rooted? Q2b: how would I write the `isRooted t` function? Feedback much appreciated. -BenRI P.S. Haskell code is here: https://github.com/bredelings/BAli-Phy/tree/master/haskell

3 3