DOCSLIB.ORG

Modern Perl for Biologists I | the Basics M-BIM / INBTBI

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Modern Perl for Biologists I | The Basics M-BIM / INBTBI Denis BAURAIN / ULiège Edition 2020–2021 Denis BAURAIN / ULiège ii Modern Perl for Biologists I | The Basics Acknowledgment This course has been developed over eight years (2013–2020) primarily as teaching materials for the Modern Perl module of the (INBTBI) Bioinformatics Training organized by the Biotechnology Training Centre in the GIGA Tower of the University of Liège (Belgium). Until 2016, the Biotechnology Training Centre was directed by Laurent Corbesier, who is warmly thanked for his support. The training itself was funded through the Bioinformatics Training Program, 6th call 2010–2014, BioWin (the Health Cluster of Wallonia), Le Forem (the Walloon Office for Employment and Training), and the Biotechnology Training Centre (Forem-GIGA). This two-part document benefitted from the feed-back of about 150 students, trainees and colleagues, among which Arnaud Di Franco, Agnieszka Misztak, Loïc Meunier and Sinaeda Anderssen are espe- cially acknowledged. If you spot typos, grammatical or technical errors, or have any suggestion on how to improve the next edition of this course, let me know ([email protected]). I will answer all messages. Finally, I thank Pierre (Pit) Tocquin for his help with the mighty triad Markdown / Pandoc / LATEX. How to read this course? This document is written in American English. The first time they are introduced, programming terms and biological terms are typeset in bold and italic, respectively, whereas computer keywords are always typeset in a monospaced font (Consolas). All these terms are indexed at most once per section in which they appear (see Index). While the main text is typeset in Palatino, user statements (either at the shell or as small code excerpts) and computer answers are typeset in the same monospaced font as computer keywords. $ echo "Hello world!" # user statement (note the shell prompt) Hello world! # computer answer Example BOX Advanced material that can be skipped on first reading is enclosed in boxes with a light blue background. A List of Boxes is available for convenience. General programming advices and good practices that apply beyond the Perl language are typeset in a smaller size and introduced by a yellow bar surmounted by an icon. 1 say <<'EOT'; 2 Complete program listings are typeset 3 in the same monospaced font as keywords. 4 Their lines are numbered. 5 EOT Denis BAURAIN / ULiège iii Modern Perl for Biologists I | The Basics Denis BAURAIN / ULiège iv Modern Perl for Biologists I | The Basics Contents Acknowledgment ......................................... iii How to read this course? ..................................... iii I Lesson 1 1 1 Introduction 3 1.1 What is Perl? ........................................ 3 1.2 What is Modern Perl? ................................... 3 1.3 Why for biologists? .................................... 4 1.4 Covered topics ....................................... 4 1.5 Homework guidelines ................................... 5 1.6 Perl Cheat Sheet ...................................... 6 2 Before beginning 9 2.1 The need for a sandbox .................................. 9 2.2 How to install our sandbox? ............................... 9 3 First steps in Perl 11 3.1 Motivation ......................................... 11 3.2 Our first killer app ..................................... 11 3.3 How to make our own rev_comp? ............................ 12 3.4 How to document our program? ............................. 14 3.5 Perl variables ........................................ 15 3.6 How to see what’s going on? ............................... 17 3.7 A closer look to our killer app ............................... 18 3.8 Basic Perl syntax ...................................... 19 3.8.1 Names ........................................ 19 3.8.2 Sigils ......................................... 20 3.8.3 Context ........................................ 20 3.8.4 Scope ......................................... 21 3.8.5 strict and warnings pragmas ........................... 23 3.9 List builtin functions .................................... 23 3.9.1 push & pop ...................................... 23 3.9.2 unshift & shift .................................. 24 3.9.3 split & join .................................... 25 4 Digging deeper into Perl 29 4.1 Another killer app ..................................... 29 4.2 The code for our own translate ............................. 30 Homework 33 Denis BAURAIN / ULiège v Modern Perl for Biologists I | The Basics CONTENTS II Lesson 2 35 5 Looking at the novelties in translate.pl 37 5.1 Shebang line ........................................ 37 5.2 Modern::Perl ....................................... 37 5.3 Perl values: Strings .................................... 38 5.3.1 Defining and concatenating strings ......................... 38 5.3.2 Alternate quoting operators ............................ 40 5.4 String builtin functions .................................. 40 5.4.1 length ........................................ 41 5.4.2 substr ........................................ 41 5.4.3 uc & lc ........................................ 42 5.5 The for loop ........................................ 43 5.5.1 foreach-style for loop ................................ 43 5.5.2 C-style for loop ................................... 45 5.6 Boolean expressions .................................... 47 5.6.1 Perl’s vision of truth ................................. 47 5.6.2 The undef value ................................... 48 5.6.3 Logical defined-or operator ............................. 48 5.7 The say builtin function .................................. 49 6 Batch vs. interactive programs 51 6.1 Acquiring user input ................................... 51 6.2 How to improve our killer app? .............................. 51 6.3 Let’s make our first game! ................................. 53 Homework 57 III Lesson 3 59 7 Becoming a control freak 61 7.1 Control flow in Perl .................................... 61 7.2 Branching directives .................................... 61 7.2.1 if & unless ..................................... 62 7.2.2 else & elsif .................................... 63 7.2.3 die and the postfix form .............................. 66 7.2.4 Interlude—defining multiline strings with the heredoc syntax . 66 7.3 Looping directives ..................................... 67 7.3.1 The while loop and its variants ........................... 68 7.3.2 Loop control directives ............................... 71 8 Other novelties in codon_quizz.pl 79 8.1 keys & shuffle ...................................... 79 8.2 Reading from the standard input stream ......................... 80 8.2.1 The readline operator ............................... 80 8.2.2 Line endings ..................................... 81 9 A first look at operators 83 9.1 What are operators? .................................... 83 9.2 Comparison operators ................................... 84 9.3 Logical operators ..................................... 85 9.4 Operator precedence and associativity .......................... 86 Denis BAURAIN / ULiège vi Modern Perl for Biologists I | The Basics CONTENTS 10 Using Perl to compute some stats 87 10.1 A killer app with a fast bite ................................ 87 10.2 The code for our own codon_usage ........................... 88 Homework 91 IV Lesson 4 93 11 Input/output in Perl 95 11.1 Reading files ........................................ 95 11.1.1 FASTA format .................................... 95 11.1.2 open & close .................................... 95 11.1.3 autodie and $! ................................... 96 11.2 Writing files ........................................ 98 12 A first look at mathematics in Perl 101 12.1 Perl values: Numbers ................................... 101 12.2 Numeric and in-place operators ............................. 102 13 More on hashes 105 13.1 Hash uses ......................................... 105 13.2 values & sort and reuse of variable names ....................... 110 14 Towards more complex programs 113 14.1 A production-grade translation tool ........................... 113 Homework 117 V Lesson 5 119 15 Looking at the novelties in xxl_xlate.pl 121 15.1 Would you like some syntactic sugar? . 121 15.1.1 Ordered hashes: Tie::IxHash . 121 15.1.2 each and list assignment .............................. 121 15.1.3 The ternary conditional operator . 122 15.2 Writing portable code ................................... 122 15.2.1 LWP::Simple ..................................... 122 15.2.2 Path::Class ..................................... 123 15.2.3 File::Basename ................................... 123 16 Regular expressions 125 16.1 What are regular expressions? .............................. 125 16.2 Defining regular expressions ............................... 125 16.3 Using regexes ....................................... 126 16.4 When not to use regexes? ................................. 127 16.4.1 Literal searches: index ............................... 128 16.4.2 Transliteration: tr/// ................................ 129 16.5 Anchors .......................................... 132 16.6 Character classes ...................................... 135 16.7 Metacharacters ....................................... 136 16.8 Quantifiers ......................................... 137 16.9 Capturing groups ..................................... 139 16.10 Non-capturing groups ................................... 142 16.11 Modifiers .........................................
Recommended publications
  • Reflection, Zips, and Generalised Casts Abstract

    Reflection, Zips, and Generalised Casts Abstract

    Scrap More Boilerplate: Reflection, Zips, and Generalised Casts Ralf L a¨mmel Vrije Universiteit & CWI, Amsterdam Abstract Writing boilerplate code is a royal pain. Generic programming promises to alleviate this pain b y allowing the programmer to write a generic #recipe$ for boilerplate code, and use that recipe in many places. In earlier work we introduced the #Scrap y our boilerplate$ approach to generic p rogramming, which exploits Haskell%s exist- ing type-class mechanism to support generic transformations and queries. This paper completes the picture. We add a few extra #introspec- tive$ or #reflective$ facilities, that together support a r ich variety of serialisation and de-serialisation. We also show how to perform generic #zips$, which at first appear to be somewhat tricky in our framework. Lastly, we generalise the ability to over-ride a generic function with a type-specific one. All of this can be supported in Haskell with independently-useful extensions: higher-rank types and type-safe cast. The GHC imple- mentation of Haskell readily derives the required type classes for user-defined data types. Categories and Subject Descriptors D.2. 13 [Software Engineering]: Reusable Software; D.1.1 [Programming Techniques]: Functional Programming; D.3. 1 [Programming Languages]: Formal Definitions and Theory General Terms Design, Languages Keywords Generic p rogramming, reflection, zippers, type cast 1 Introduction It is common to find that large slabs of a program consist of #boil- erplate$ code, which conceals b y its b ulk a smaller amount of #in- teresting$ code. So-called generic p rogramming techniques allow Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or c ommercial advantage and that copies b ear this notice and the full citation on the first page.
  • PRE PROCESSOR DIRECTIVES in –C LANGUAGE. 2401 – Course

    PRE PROCESSOR DIRECTIVES in –C LANGUAGE. 2401 – Course

    PRE PROCESSOR DIRECTIVES IN –C LANGUAGE. 2401 – Course Notes. 1 The C preprocessor is a macro processor that is used automatically by the C compiler to transform programmer defined programs before actual compilation takes place. It is called a macro processor because it allows the user to define macros, which are short abbreviations for longer constructs. This functionality allows for some very useful and practical tools to design our programs. To include header files(Header files are files with pre defined function definitions, user defined data types, declarations that can be included.) To include macro expansions. We can take random fragments of C code and abbreviate them into smaller definitions namely macros, and once they are defined and included via header files or directly onto the program itself it(the user defined definition) can be used everywhere in the program. In other words it works like a blank tile in the game scrabble, where if one player possesses a blank tile and uses it to state a particular letter for a given word he chose to play then that blank piece is used as that letter throughout the game. It is pretty similar to that rule. Special pre processing directives can be used to, include or exclude parts of the program according to various conditions. To sum up, preprocessing directives occurs before program compilation. So, it can be also be referred to as pre compiled fragments of code. Some possible actions are the inclusions of other files in the file being compiled, definitions of symbolic constants and macros and conditional compilation of program code and conditional execution of preprocessor directives.
  • Template Meta-Programming for Haskell

    Template Meta-Programming for Haskell

    Template Meta-programming for Haskell Tim Sheard Simon Peyton Jones OGI School of Science & Engineering Microsoft Research Ltd Oregon Health & Science University [email protected] [email protected] Abstract C++, albeit imperfectly... [It is] obvious to functional programmers what the committee did not realize until We propose a new extension to the purely functional programming later: [C++] templates are a functional language evalu- language Haskell that supports compile-time meta-programming. ated at compile time...” [12]. The purpose of the system is to support the algorithmic construction of programs at compile-time. Robinson’s provocative paper identifies C++ templates as a ma- The ability to generate code at compile time allows the program- jor, albeit accidental, success of the C++ language design. De- mer to implement such features as polytypic programs, macro-like spite the extremely baroque nature of template meta-programming, expansion, user directed optimization (such as inlining), and the templates are used in fascinating ways that extend beyond the generation of supporting data structures and functions from exist- wildest dreams of the language designers [1]. Perhaps surprisingly, ing data structures and functions. in view of the fact that templates are functional programs, func- tional programmers have been slow to capitalize on C++’s success; Our design is being implemented in the Glasgow Haskell Compiler, while there has been a recent flurry of work on run-time meta- ghc. programming, much less has been done on compile-time meta- This version is very slightly modified from the Haskell Workshop programming. The Scheme community is a notable exception, as 2002 publication; a couple of typographical errors are fixed in Fig- we discuss in Section 10.
  • C and C++ Preprocessor Directives #Include #Define Macros Inline

    C and C++ Preprocessor Directives #Include #Define Macros Inline

    MODULE 10 PREPROCESSOR DIRECTIVES My Training Period: hours Abilities ▪ Able to understand and use #include. ▪ Able to understand and use #define. ▪ Able to understand and use macros and inline functions. ▪ Able to understand and use the conditional compilation – #if, #endif, #ifdef, #else, #ifndef and #undef. ▪ Able to understand and use #error, #pragma, # and ## operators and #line. ▪ Able to display error messages during conditional compilation. ▪ Able to understand and use assertions. 10.1 Introduction - For C/C++ preprocessor, preprocessing occurs before a program is compiled. A complete process involved during the preprocessing, compiling and linking can be read in Module W. - Some possible actions are: ▪ Inclusion of other files in the file being compiled. ▪ Definition of symbolic constants and macros. ▪ Conditional compilation of program code or code segment. ▪ Conditional execution of preprocessor directives. - All preprocessor directives begin with #, and only white space characters may appear before a preprocessor directive on a line. 10.2 The #include Preprocessor Directive - The #include directive causes copy of a specified file to be included in place of the directive. The two forms of the #include directive are: //searches for header files and replaces this directive //with the entire contents of the header file here #include <header_file> - Or #include "header_file" e.g. #include <stdio.h> #include "myheader.h" - If the file name is enclosed in double quotes, the preprocessor searches in the same directory (local) as the source file being compiled for the file to be included, if not found then looks in the subdirectory associated with standard header files as specified using angle bracket. - This method is normally used to include user or programmer-defined header files.
  • Metaprogramming Concepts of Programming Languages

    Metaprogramming Concepts of Programming Languages

    Metaprogramming Concepts of Programming Languages Alexander Schramm Institut für Softwaretechnik und Programmiersprachen 2. November 2015 A. Schramm 2. November 2015 1/39 Table of Contents Introduction Runtime Reflection in Java Runtime Metaprogramming in Ruby C++ Templates Haskell Templates Lisp Macros Conclusion A. Schramm 2. November 2015 2/39 Outline Introduction Runtime Reflection in Java Runtime Metaprogramming in Ruby C++ Templates Haskell Templates Lisp Macros Conclusion A. Schramm 2. November 2015 3/39 Motivation Which issues do we want to tackle? I Avoid writing boilerplate code I Write code that shows our intention I Expand the syntax of languages I Write type independent code in strongly typed languages A. Schramm 2. November 2015 4/39 What is Metaprogramming Definition: Metaprogramming Metaprograming describes different ways to generate and manipulate code Differentations: I Compile time vs. runtime metaprogramming I Domain language vs. host language A. Schramm 2. November 2015 5/39 Differentations of Metaprograms Compile time Metaprogramming Ways to manipulate or generate code during compilation, e.g: Macros, Templates Runtime Metaprogramming Ways to manipulate or generate code, while it is executed, e.g: dynamic methods, Reflections A. Schramm 2. November 2015 6/39 Differentations of Metaprograms Domain Language The Programming Language, in which the metaprogram is written Host Language The Programming Language of the generated code I Can be different (YACC, Compilers) I Domain language can be a subset of the host language (C++ Templates) I Domain language can be an integral part of the host language (Ruby) A. Schramm 2. November 2015 7/39 Outline Introduction Runtime Reflection in Java Runtime Metaprogramming in Ruby C++ Templates Haskell Templates Lisp Macros Conclusion A.
  • MANNING Greenwich (74° W

    MANNING Greenwich (74° W

    Object Oriented Perl Object Oriented Perl DAMIAN CONWAY MANNING Greenwich (74° w. long.) For electronic browsing and ordering of this and other Manning books, visit http://www.manning.com. The publisher offers discounts on this book when ordered in quantity. For more information, please contact: Special Sales Department Manning Publications Co. 32 Lafayette Place Fax: (203) 661-9018 Greenwich, CT 06830 email: [email protected] ©2000 by Manning Publications Co. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, mechanical, photocopying, or otherwise, without prior written permission of the publisher. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in the book, and Manning Publications was aware of a trademark claim, the designations have been printed in initial caps or all caps. Recognizing the importance of preserving what has been written, it is Manning’s policy to have the books we publish printed on acid-free paper, and we exert our best efforts to that end. Library of Congress Cataloging-in-Publication Data Conway, Damian, 1964- Object oriented Perl / Damian Conway. p. cm. includes bibliographical references. ISBN 1-884777-79-1 (alk. paper) 1. Object-oriented programming (Computer science) 2. Perl (Computer program language) I. Title. QA76.64.C639 1999 005.13'3--dc21 99-27793 CIP Manning Publications Co. Copyeditor: Adrianne Harun 32 Lafayette
  • A Call-By-Need Lambda Calculus

    A Call-By-Need Lambda Calculus

    A CallByNeed Lamb da Calculus Zena M Ariola Matthias Fel leisen Computer Information Science Department Department of Computer Science University of Oregon Rice University Eugene Oregon Houston Texas John Maraist and Martin Odersky Philip Wad ler Institut fur Programmstrukturen Department of Computing Science Universitat Karlsruhe UniversityofGlasgow Karlsruhe Germany Glasgow Scotland Abstract arguments value when it is rst evaluated More pre cisely lazy languages only reduce an argument if the The mismatchbetween the op erational semantics of the value of the corresp onding formal parameter is needed lamb da calculus and the actual b ehavior of implemen for the evaluation of the pro cedure b o dy Moreover af tations is a ma jor obstacle for compiler writers They ter reducing the argument the evaluator will remember cannot explain the b ehavior of their evaluator in terms the resulting value for future references to that formal of source level syntax and they cannot easily com parameter This technique of evaluating pro cedure pa pare distinct implementations of dierent lazy strate rameters is called cal lbyneed or lazy evaluation gies In this pap er we derive an equational characteri A simple observation justies callbyneed the re zation of callbyneed and prove it correct with resp ect sult of reducing an expression if any is indistinguish to the original lamb da calculus The theory is a strictly able from the expression itself in all p ossible contexts smaller theory than the lamb da calculus Immediate Some implementations attempt
  • Understanding the Syntactic Rule Usage in Java

    Understanding the Syntactic Rule Usage in Java

    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by UCL Discovery Understanding the Syntactic Rule Usage in Java Dong Qiua, Bixin Lia,∗, Earl T. Barrb, Zhendong Suc aSchool of Computer Science and Engineering, Southeast University, China bDepartment of Computer Science, University College London, UK cDepartment of Computer Science, University of California Davis, USA Abstract Context: Syntax is fundamental to any programming language: syntax defines valid programs. In the 1970s, computer scientists rigorously and empirically studied programming languages to guide and inform language design. Since then, language design has been artistic, driven by the aesthetic concerns and intuitions of language architects. Despite recent studies on small sets of selected language features, we lack a comprehensive, quantitative, empirical analysis of how modern, real-world source code exercises the syntax of its programming language. Objective: This study aims to understand how programming language syntax is employed in actual development and explore their potential applications based on the results of syntax usage analysis. Method: We present our results on the first such study on Java, a modern, mature, and widely-used programming language. Our corpus contains over 5,000 open-source Java projects, totalling 150 million source lines of code (SLoC). We study both independent (i.e. applications of a single syntax rule) and dependent (i.e. applications of multiple syntax rules) rule usage, and quantify their impact over time and project size. Results: Our study provides detailed quantitative information and yields insight, particularly (i) confirming the conventional wisdom that the usage of syntax rules is Zipfian; (ii) showing that the adoption of new rules and their impact on the usage of pre-existing rules vary significantly over time; and (iii) showing that rule usage is highly contextual.
  • S-Algol Reference Manual Ron Morrison

    S-Algol Reference Manual Ron Morrison

    S-algol Reference Manual Ron Morrison University of St. Andrews, North Haugh, Fife, Scotland. KY16 9SS CS/79/1 1 Contents Chapter 1. Preface 2. Syntax Specification 3. Types and Type Rules 3.1 Universe of Discourse 3.2 Type Rules 4. Literals 4.1 Integer Literals 4.2 Real Literals 4.3 Boolean Literals 4.4 String Literals 4.5 Pixel Literals 4.6 File Literal 4.7 pntr Literal 5. Primitive Expressions and Operators 5.1 Boolean Expressions 5.2 Comparison Operators 5.3 Arithmetic Expressions 5.4 Arithmetic Precedence Rules 5.5 String Expressions 5.6 Picture Expressions 5.7 Pixel Expressions 5.8 Precedence Table 5.9 Other Expressions 6. Declarations 6.1 Identifiers 6.2 Variables, Constants and Declaration of Data Objects 6.3 Sequences 6.4 Brackets 6.5 Scope Rules 7. Clauses 7.1 Assignment Clause 7.2 if Clause 7.3 case Clause 7.4 repeat ... while ... do ... Clause 7.5 for Clause 7.6 abort Clause 8. Procedures 8.1 Declarations and Calls 8.2 Forward Declarations 2 9. Aggregates 9.1 Vectors 9.1.1 Creation of Vectors 9.1.2 upb and lwb 9.1.3 Indexing 9.1.4 Equality and Equivalence 9.2 Structures 9.2.1 Creation of Structures 9.2.2 Equality and Equivalence 9.2.3 Indexing 9.3 Images 9.3.1 Creation of Images 9.3.2 Indexing 9.3.3 Depth Selection 9.3.4 Equality and Equivalence 10. Input and Output 10.1 Input 10.2 Output 10.3 i.w, s.w and r.w 10.4 End of File 11.
  • Section “Common Predefined Macros” in the C Preprocessor

    Section “Common Predefined Macros” in the C Preprocessor

    The C Preprocessor For gcc version 12.0.0 (pre-release) (GCC) Richard M. Stallman, Zachary Weinberg Copyright c 1987-2021 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation. A copy of the license is included in the section entitled \GNU Free Documentation License". This manual contains no Invariant Sections. The Front-Cover Texts are (a) (see below), and the Back-Cover Texts are (b) (see below). (a) The FSF's Front-Cover Text is: A GNU Manual (b) The FSF's Back-Cover Text is: You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development. i Table of Contents 1 Overview :::::::::::::::::::::::::::::::::::::::: 1 1.1 Character sets:::::::::::::::::::::::::::::::::::::::::::::::::: 1 1.2 Initial processing ::::::::::::::::::::::::::::::::::::::::::::::: 2 1.3 Tokenization ::::::::::::::::::::::::::::::::::::::::::::::::::: 4 1.4 The preprocessing language :::::::::::::::::::::::::::::::::::: 6 2 Header Files::::::::::::::::::::::::::::::::::::: 7 2.1 Include Syntax ::::::::::::::::::::::::::::::::::::::::::::::::: 7 2.2 Include Operation :::::::::::::::::::::::::::::::::::::::::::::: 8 2.3 Search Path :::::::::::::::::::::::::::::::::::::::::::::::::::: 9 2.4 Once-Only Headers::::::::::::::::::::::::::::::::::::::::::::: 9 2.5 Alternatives to Wrapper #ifndef ::::::::::::::::::::::::::::::
  • NU-Prolog Reference Manual

    NU-Prolog Reference Manual

    NU-Prolog Reference Manual Version 1.5.24 edited by James A. Thom & Justin Zobel Technical Report 86/10 Machine Intelligence Project Department of Computer Science University of Melbourne (Revised November 1990) Copyright 1986, 1987, 1988, Machine Intelligence Project, The University of Melbourne. All rights reserved. The Technical Report edition of this publication is given away free subject to the condition that it shall not, by the way of trade or otherwise, be lent, resold, hired out, or otherwise circulated, without the prior consent of the Machine Intelligence Project at the University of Melbourne, in any form or cover other than that in which it is published and without a similar condition including this condition being imposed on the subsequent user. The Machine Intelligence Project makes no representations or warranties with respect to the contents of this document and specifically disclaims any implied warranties of merchantability or fitness for any particular purpose. Furthermore, the Machine Intelligence Project reserves the right to revise this document and to make changes from time to time in its content without being obligated to notify any person or body of such revisions or changes. The usual codicil that no part of this publication may be reproduced, stored in a retrieval system, used for wrapping fish, or transmitted, in any form or by any means, electronic, mechanical, photocopying, paper dart, recording, or otherwise, without someone's express permission, is not imposed. Enquiries relating to the acquisition of NU-Prolog should be made to NU-Prolog Distribution Manager Machine Intelligence Project Department of Computer Science The University of Melbourne Parkville, Victoria 3052 Australia Telephone: (03) 344 5229.
  • Sugarj: Library-Based Syntactic Language Extensibility

    Sugarj: Library-Based Syntactic Language Extensibility

    SugarJ: Library-based Syntactic Language Extensibility Sebastian Erdweg, Tillmann Rendel, Christian Kastner,¨ and Klaus Ostermann University of Marburg, Germany Abstract import pair.Sugar; Existing approaches to extend a programming language with syntactic sugar often leave a bitter taste, because they cannot public class Test f be used with the same ease as the main extension mechanism private (String, Integer) p = ("12", 34); of the programming language—libraries. Sugar libraries are g a novel approach for syntactically extending a programming Figure 1. Using a sugar library for pairs. language within the language. A sugar library is like an or- dinary library, but can, in addition, export syntactic sugar for using the library. Sugar libraries maintain the compos- 1. Introduction ability and scoping properties of ordinary libraries and are Bridging the gap between domain concepts and the imple- hence particularly well-suited for embedding a multitude of mentation of these concepts in a programming language is domain-specific languages into a host language. They also one of the “holy grails” of software development. Domain- inherit self-applicability from libraries, which means that specific languages (DSLs), such as regular expressions for sugar libraries can provide syntactic extensions for the defi- the domain of text recognition or Java Server Pages for the nition of other sugar libraries. domain of dynamic web pages have often been proposed To demonstrate the expressiveness and applicability of to address this problem [31]. To use DSLs in large soft- sugar libraries, we have developed SugarJ, a language on ware systems that touch multiple domains, developers have top of Java, SDF and Stratego, which supports syntactic to be able to compose multiple domain-specific languages extensibility.