DOCSLIB.ORG

Advanced Logical Type Systems for Untyped Languages

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Advanced Logical Type Systems for Untyped Languages ADVANCED LOGICAL TYPE SYSTEMS FOR UNTYPED LANGUAGES Andrew M. Kent Submitted to the faculty of the University Graduate School in partial fulfillment of the requirements for the degree Doctor of Philosophy in the Department of Computer Science, Indiana University October 2019 Accepted by the Graduate Faculty, Indiana University, in partial fulfillment of the requirements for the degree of Doctor of Philosophy. Doctoral Committee Sam Tobin-Hochstadt, Ph.D. Jeremy Siek, Ph.D. Ryan Newton, Ph.D. Larry Moss, Ph.D. Date of Defense: 9/6/2019 ii Copyright © 2019 Andrew M. Kent iii To Caroline, for both putting up with all of this and helping me stay sane throughout. Words could never fully capture how grateful I am to have her in my life. iv ACKNOWLEDGEMENTS None of this would have been possible without the community of academics and friends I was lucky enough to have been surrounded by during these past years. From patiently helping me understand concepts to listening to me stumble through descriptions of half- baked ideas, I cannot thank enough my advisor and the professors and peers that donated a portion of their time to help me along this journey. v Andrew M. Kent ADVANCED LOGICAL TYPE SYSTEMS FOR UNTYPED LANGUAGES Type systems with occurrence typing—the ability to refine the type of terms in a control flow sensitive way—now exist for nearly every untyped programming language that has gained popularity. While these systems have been successful in type checking many prevalent idioms, most have focused on relatively simple verification goals and coarse interface specifications. We demonstrate that such systems are naturally suited for combination with more advanced type theoretic concepts—specifically refinement types and semantic subtyping—with both formal mathematical models and experiences reports from implementing such systems at scale. Sam Tobin-Hochstadt, Ph.D. Jeremy Siek, Ph.D. Ryan Newton, Ph.D. Larry Moss, Ph.D. vi TABLE OF CONTENTS Acknowledgements .................................. v Abstract ........................................ vi List of Figures ..................................... xi Chapter 1: Introduction and Background .................... 1 1.1 Refinement Types ................................ 2 1.2 Set-theoretic types ................................ 3 1.3 Thesis Statement and Outline .......................... 6 Chapter 2: Occurrence Typing .......................... 8 2.1 Occurrence Typing Examples .......................... 9 2.2 λOT : A Calculus for Occurrence Typing .................... 14 2.2.1 λOT Syntax ................................ 14 2.2.2 λOT Type System ............................ 16 2.2.3 λOT Subtyping .............................. 19 2.2.4 λOT Logic and Type Metafunctions . 19 2.2.5 λOT Semantics .............................. 23 2.2.6 λOT Soundness .............................. 25 2.2.7 Scaling Up λOT .............................. 26 2.2.8 Related Work in Occurrence Typing . 30 vii Chapter 3: Occurrence Typing with Refinement Types ............ 35 3.1 Beyond Occurrence Typing ........................... 37 3.1.1 Occurrence Typing with Linear Arithmetic . 37 3.1.2 Occurrence Typing with Bitvectors ................... 39 3.2 Formal Model ................................... 40 3.2.1 Syntax ................................... 40 3.2.2 Typing Rules ............................... 43 3.2.3 Subtyping and Proof System ...................... 46 3.2.4 Integrating Additional Theories ..................... 51 3.2.5 Semantics and Soundness ........................ 52 3.3 Scaling to a Real Implementation ........................ 55 3.3.1 Efficient, Algorithmic Subtyping .................... 55 3.3.2 Mutation ................................. 56 3.3.3 Type Inference and Polymorphism ................... 57 3.3.4 Complex Macros ............................. 57 3.4 Case Study: Safe Vector Access ......................... 59 3.4.1 Enriching the Math Library ....................... 60 3.5 Adding Refinements to Typed Racket ..................... 62 3.5.1 Compiling Dependent Types into Contracts . 64 3.5.2 Pay-as-you-go costs for developers ................... 65 3.5.3 Dealing with Existentials ........................ 65 3.6 Related Work ................................... 66 Chapter 4: Semantic Subtyping .......................... 69 4.1 Set-theoretic Types ................................ 69 viii 4.1.1 Subtyping ................................. 70 4.1.2 Semantic Subtyping ........................... 71 4.1.3 Deciding Inhabitation, Normal Forms . 72 4.2 Type Representation ............................... 75 4.2.1 Types as Data Structures ........................ 75 4.2.2 Base DNF Representation ........................ 77 4.2.3 Product and Function DNFs ...................... 80 4.2.4 Parsing and Example Types ....................... 84 4.3 Type Inhabitation ................................ 85 4.3.1 Deciding Type Inhabitation ....................... 86 4.4 Other Type-level Metafunctions ......................... 92 4.4.1 Product Projection ............................ 92 4.4.2 Function Domain ............................. 94 4.4.3 Function Application ........................... 95 4.5 Strategies for Testing ............................... 98 4.6 Related Work ................................... 99 4.6.1 Other Tutorials and Overviews ..................... 99 4.6.2 First-order or incomplete semantic subtyping . 100 4.6.3 Semantic subtyping with additional features . 101 4.6.4 Expressive Syntactic Subtyping . 101 Chapter 5: A Set-theoretic Foundation for Occurrence Typing ....... 103 5.1 Logical Inversion ................................. 103 5.1.1 Function Application Inversion . 105 5.1.2 Algorithm Intuition . 106 ix 5.1.3 Algorithm ................................. 107 5.1.4 Soundness and Completeness . 108 5.1.5 Efficient Implementation . 109 5.1.6 Conservative Function Application Inversion . 111 5.2 Formal Language Model ............................. 112 5.2.1 λSO Syntax ................................ 113 5.2.2 λSO Type System ............................ 115 5.2.3 λSO Semantics .............................. 119 5.2.4 λSO Soundness .............................. 119 5.2.5 Additional Language Features . 123 5.3 Semantic Numeric Tower ............................. 124 5.3.1 Semantic Types for Comparison Operators . 125 5.3.2 Semantic Types for Other Numeric Operators . 128 5.3.3 Semantic/Syntactic Function Type Comparison . 130 5.3.4 Challenges and Future Work . 132 5.4 Expressiveness .................................. 133 5.5 Related Work ................................... 136 Appendix A: Function Application Inversion Proofs ............. 138 Appendix B: Numeric Tower Types ....................... 156 Appendix C: CDuce Numeric Tower ....................... 166 References ....................................... 169 Curriculum Vitae x LIST OF FIGURES 2.1 λOT Syntax .................................... 15 2.2 λOT Typing Judgment .............................. 17 2.3 λOT Constant Type-Results ........................... 17 2.4 λOT Subtyping .................................. 20 2.5 λOT Type-related Logic Rules and Metafunctions . 21 2.6 λOT Big-step Reduction Relation ........................ 24 2.7 λOT Primitive Types ............................... 24 2.8 λOT Models Relation ............................... 25 3.1 max with refinement types ............................ 36 3.2 λRT R Syntax ................................... 41 3.3 λRT R Primitive Types .............................. 43 3.4 λRT R Typing Judgment ............................. 44 3.5 λRT R Subtyping ................................. 47 3.6 λRT R-specific Logic Rules ............................ 48 3.7 λRT R type-update metafunction ......................... 50 3.8 λRT R Big-step Reduction Relation ....................... 52 3.9 λRT R Primitive Semantics ............................ 53 3.10 λRT R Models Relation .............................. 53 xi 3.11 safe-vec-ref case study ............................ 60 4.1 Set-theoretic Types ................................ 69 4.2 Subtyping/Inhabitation Equivalence ...................... 72 4.3 Canonical form for representing types ..................... 74 4.4 Internal type representation ........................... 76 4.5 Top and bottom type representations ...................... 77 4.6 Internal type operations ............................. 78 4.7 Internal base type representation ........................ 79 4.8 Internal base DNF operations .......................... 79 4.9 Lazy BDDs for type representation ....................... 83 4.10 BDD node smart constructor .......................... 84 4.11 BDD difference and negation .......................... 85 4.12 BDD union and intersection ........................... 86 4.13 Type parsing ................................... 87 4.14 Semantic subtyping, defined in terms of type emptiness . 87 4.15 Type emptiness predicate ............................ 87 4.16 Sets of atoms ................................... 88 4.17 Product BDD inhabitation functions ...................... 89 4.18 Functions for checking if a function BDD is uninhabited . 91 4.19 Functions for projecting from a product type . 94 4.20 Domain calculation for function types ..................... 95 4.21 Function application result type calculations . 98 5.1 Function Application Inversion Examples . 106 xii 5.2 Function Application Inversion Algorithm . 108 5.3 Efficient algorithm for function application inversion. 110 5.4 Conservative Function Application Inversion Algorithm . 112
Load more

Recommended publications
  • Dotty Phantom Types (Technical Report)
    Dotty Phantom Types (Technical Report) Nicolas Stucki Aggelos Biboudis Martin Odersky École Polytechnique Fédérale de Lausanne Switzerland Abstract 2006] and even a lightweight form of dependent types [Kise- Phantom types are a well-known type-level, design pattern lyov and Shan 2007]. which is commonly used to express constraints encoded in There are two ways of using phantoms as a design pattern: types. We observe that in modern, multi-paradigm program- a) relying solely on type unication and b) relying on term- ming languages, these encodings are too restrictive or do level evidences. According to the rst way, phantoms are not provide the guarantees that phantom types try to en- encoded with type parameters which must be satised at the force. Furthermore, in some cases they introduce unwanted use-site. The declaration of turnOn expresses the following runtime overhead. constraint: if the state of the machine, S, is Off then T can be We propose a new design for phantom types as a language instantiated, otherwise the bounds of T are not satisable. feature that: (a) solves the aforementioned issues and (b) makes the rst step towards new programming paradigms type State; type On <: State; type Off <: State class Machine[S <: State] { such as proof-carrying code and static capabilities. This pa- def turnOn[T >: S <: Off] = new Machine[On] per presents the design of phantom types for Scala, as im- } new Machine[Off].turnOn plemented in the Dotty compiler. An alternative way to encode the same constraint is by 1 Introduction using an implicit evidence term of type =:=, which is globally Parametric polymorphism has been one of the most popu- available.
    [Show full text]
  • Functional SMT Solving: a New Interface for Programmers
    Functional SMT solving: A new interface for programmers A thesis submitted in Partial Fulfillment of the Requirements for the Degree of Master of Technology by Siddharth Agarwal to the DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING INDIAN INSTITUTE OF TECHNOLOGY KANPUR June, 2012 v ABSTRACT Name of student: Siddharth Agarwal Roll no: Y7027429 Degree for which submitted: Master of Technology Department: Computer Science & Engineering Thesis title: Functional SMT solving: A new interface for programmers Name of Thesis Supervisor: Prof Amey Karkare Month and year of thesis submission: June, 2012 Satisfiability Modulo Theories (SMT) solvers are powerful tools that can quickly solve complex constraints involving booleans, integers, first-order logic predicates, lists, and other data types. They have a vast number of potential applications, from constraint solving to program analysis and verification. However, they are so complex to use that their power is inaccessible to all but experts in the field. We present an attempt to make using SMT solvers simpler by integrating the Z3 solver into a host language, Racket. Our system defines a programmer’s interface in Racket that makes it easy to harness the power of Z3 to discover solutions to logical constraints. The interface, although in Racket, retains the structure and brevity of the SMT-LIB format. We demonstrate this using a range of examples, from simple constraint solving to verifying recursive functions, all in a few lines of code. To my grandfather Acknowledgements This project would have never have even been started had it not been for my thesis advisor Dr Amey Karkare’s help and guidance. Right from the time we were looking for ideas to when we finally had a concrete proposal in hand, his support has been invaluable.
    [Show full text]
  • Cross-Platform Language Design
    Cross-Platform Language Design THIS IS A TEMPORARY TITLE PAGE It will be replaced for the final print by a version provided by the service academique. Thèse n. 1234 2011 présentée le 11 Juin 2018 à la Faculté Informatique et Communications Laboratoire de Méthodes de Programmation 1 programme doctoral en Informatique et Communications École Polytechnique Fédérale de Lausanne pour l’obtention du grade de Docteur ès Sciences par Sébastien Doeraene acceptée sur proposition du jury: Prof James Larus, président du jury Prof Martin Odersky, directeur de thèse Prof Edouard Bugnion, rapporteur Dr Andreas Rossberg, rapporteur Prof Peter Van Roy, rapporteur Lausanne, EPFL, 2018 It is better to repent a sin than regret the loss of a pleasure. — Oscar Wilde Acknowledgments Although there is only one name written in a large font on the front page, there are many people without which this thesis would never have happened, or would not have been quite the same. Five years is a long time, during which I had the privilege to work, discuss, sing, learn and have fun with many people. I am afraid to make a list, for I am sure I will forget some. Nevertheless, I will try my best. First, I would like to thank my advisor, Martin Odersky, for giving me the opportunity to fulfill a dream, that of being part of the design and development team of my favorite programming language. Many thanks for letting me explore the design of Scala.js in my own way, while at the same time always being there when I needed him.
    [Show full text]
  • Feature-Specific Profiling
    Feature-Specific Profiling LEIF ANDERSEN, PLT @ Northeastern University, United States of America VINCENT ST-AMOUR, PLT @ Northwestern University, United States of America JAN VITEK, Northeastern University and Czech Technical University MATTHIAS FELLEISEN, PLT @ Northeastern University, United States of America While high-level languages come with significant readability and maintainability benefits, their performance remains difficult to predict. For example, programmers may unknowingly use language features inappropriately, which cause their programs to run slower than expected. To address this issue, we introduce feature-specific profiling, a technique that reports performance costs in terms of linguistic constructs. Festure-specific profilers help programmers find expensive uses of specific features of their language. We describe the architecture ofa profiler that implements our approach, explain prototypes of the profiler for two languages withdifferent characteristics and implementation strategies, and provide empirical evidence for the approach’s general usefulness as a performance debugging tool. ACM Reference Format: Leif Andersen, Vincent St-Amour, Jan Vitek, and Matthias Felleisen. 2018. Feature-Specific Profiling. 1,1 (September 2018), 35 pages. https://doi.org/10.1145/nnnnnnn.nnnnnnn 1 PROFILING WITH ACTIONABLE ADVICE When programs take too long to run, programmers tend to reach for profilers to diagnose the problem. Most profilers attribute the run-time costs during a program’s execution to cost centers such as function calls or statements in source code. Then they rank all of a program’s cost centers in order to identify and eliminate key bottlenecks (Amdahl 1967). If such a profile helps programmers optimize their code, we call it actionable because it points to inefficiencies that can be remedied with changes to the program.
    [Show full text]
  • Blossom: a Language Built to Grow
    Macalester College DigitalCommons@Macalester College Mathematics, Statistics, and Computer Science Honors Projects Mathematics, Statistics, and Computer Science 4-26-2016 Blossom: A Language Built to Grow Jeffrey Lyman Macalester College Follow this and additional works at: https://digitalcommons.macalester.edu/mathcs_honors Part of the Computer Sciences Commons, Mathematics Commons, and the Statistics and Probability Commons Recommended Citation Lyman, Jeffrey, "Blossom: A Language Built to Grow" (2016). Mathematics, Statistics, and Computer Science Honors Projects. 45. https://digitalcommons.macalester.edu/mathcs_honors/45 This Honors Project - Open Access is brought to you for free and open access by the Mathematics, Statistics, and Computer Science at DigitalCommons@Macalester College. It has been accepted for inclusion in Mathematics, Statistics, and Computer Science Honors Projects by an authorized administrator of DigitalCommons@Macalester College. For more information, please contact [email protected]. In Memory of Daniel Schanus Macalester College Department of Mathematics, Statistics, and Computer Science Blossom A Language Built to Grow Jeffrey Lyman April 26, 2016 Advisor Libby Shoop Readers Paul Cantrell, Brett Jackson, Libby Shoop Contents 1 Introduction 4 1.1 Blossom . .4 2 Theoretic Basis 6 2.1 The Potential of Types . .6 2.2 Type basics . .6 2.3 Subtyping . .7 2.4 Duck Typing . .8 2.5 Hindley Milner Typing . .9 2.6 Typeclasses . 10 2.7 Type Level Operators . 11 2.8 Dependent types . 11 2.9 Hoare Types . 12 2.10 Success Types . 13 2.11 Gradual Typing . 14 2.12 Synthesis . 14 3 Language Description 16 3.1 Design goals . 16 3.2 Type System . 17 3.3 Hello World .
    [Show full text]
  • Webassembly Specification
    WebAssembly Specification Release 1.1 WebAssembly Community Group Andreas Rossberg (editor) Mar 11, 2021 Contents 1 Introduction 1 1.1 Introduction.............................................1 1.2 Overview...............................................3 2 Structure 5 2.1 Conventions.............................................5 2.2 Values................................................7 2.3 Types.................................................8 2.4 Instructions.............................................. 11 2.5 Modules............................................... 15 3 Validation 21 3.1 Conventions............................................. 21 3.2 Types................................................. 24 3.3 Instructions.............................................. 27 3.4 Modules............................................... 39 4 Execution 47 4.1 Conventions............................................. 47 4.2 Runtime Structure.......................................... 49 4.3 Numerics............................................... 56 4.4 Instructions.............................................. 76 4.5 Modules............................................... 98 5 Binary Format 109 5.1 Conventions............................................. 109 5.2 Values................................................ 111 5.3 Types................................................. 112 5.4 Instructions.............................................. 114 5.5 Modules............................................... 120 6 Text Format 127 6.1 Conventions............................................
    [Show full text]
  • Meta-Tracing Makes a Fast Racket
    Meta-tracing makes a fast Racket Carl Friedrich Bolz Tobias Pape Jeremy Siek Software Development Team Hasso-Plattner-Institut Indiana University King’s College London Potsdam [email protected] [email protected] [email protected] potsdam.de Sam Tobin-Hochstadt Indiana University [email protected] ABSTRACT 1. INTRODUCTION Tracing just-in-time (JIT) compilers record and optimize the instruc- Just-in-time (JIT) compilation has been applied to a wide variety tion sequences they observe at runtime. With some modifications, languages, with early examples including Lisp, APL, Basic, Fortran, a tracing JIT can perform well even when the executed program is Smalltalk, and Self [Aycock, 2003]. These days, JIT compilation itself an interpreter, an approach called meta-tracing. The advantage is mainstream; it is responsible for running both server-side Java of meta-tracing is that it separates the concern of JIT compilation applications [Paleczny et al., 2001] and client-side JavaScript appli- from language implementation, enabling the same JIT compiler to cations in web browsers [Hölttä, 2013]. be used with many different languages. The RPython meta-tracing Mitchell [1970] observed that one could obtain an instruction JIT compiler has enabled the efficient interpretation of several dy- sequence from an interpreter by recording its actions. The interpreter namic languages including Python (PyPy), Prolog, and Smalltalk. can then jump to this instruction sequence, this trace, when it returns In this paper we present initial findings in applying the RPython to interpret the same part of the program. For if-then-else statements, JIT to Racket. Racket comes from the Scheme family of program- there is a trace for only one branch.
    [Show full text]
  • Functional SMT Solving with Z3 and Racket
    Functional SMT Solving with Z3 and Racket Siddharth Agarwal∗y Amey Karkarey [email protected] [email protected] ∗Facebook Inc, yDepartment of Computer Science & Engineering Menlo Park, CA, USA Indian Institute of Technology Kanpur, India Abstract—Satisfiability Modulo Theories (SMT) solvers are can attack range from simple puzzles like Sudoku and n- powerful tools that can quickly solve complex constraints queens, to planning and scheduling, program analysis [8], involving Booleans, integers, first-order logic predicates, lists, whitebox fuzz testing [9] and bounded model checking [10]. and other data types. They have a vast number of potential Yet SMT solvers are only used by a small number of experts. It applications, from constraint solving to program analysis and isn’t hard to see why: the standard way for programs to interact verification. However, they are so complex to use that their power with SMT solvers like Z3 [4], Yices [5] and CVC3 [11] is via is inaccessible to all but experts in the field. We present an attempt to make using SMT solvers simpler by integrating the powerful but relatively arcane C APIs that require the users Z3 solver into a host language, Racket. The system defines a to know the particular solver’s internals. For example, here programmer’s interface in Racket that makes it easy to harness is a C program that asks Z3 whether the simple proposition the power of Z3 to discover solutions to logical constraints. The p ^ :p is satisfiable. interface, although in Racket, retains the structure and brevity Z3_config cfg = Z3_mk_config(); of the SMT-LIB format.
    [Show full text]
  • Comparative Studies of 10 Programming Languages Within 10 Diverse Criteria
    Department of Computer Science and Software Engineering Comparative Studies of 10 Programming Languages within 10 Diverse Criteria Jiang Li Sleiman Rabah Concordia University Concordia University Montreal, Quebec, Concordia Montreal, Quebec, Concordia [email protected] [email protected] Mingzhi Liu Yuanwei Lai Concordia University Concordia University Montreal, Quebec, Concordia Montreal, Quebec, Concordia [email protected] [email protected] COMP 6411 - A Comparative studies of programming languages 1/139 Sleiman Rabah, Jiang Li, Mingzhi Liu, Yuanwei Lai This page was intentionally left blank COMP 6411 - A Comparative studies of programming languages 2/139 Sleiman Rabah, Jiang Li, Mingzhi Liu, Yuanwei Lai Abstract There are many programming languages in the world today.Each language has their advantage and disavantage. In this paper, we will discuss ten programming languages: C++, C#, Java, Groovy, JavaScript, PHP, Schalar, Scheme, Haskell and AspectJ. We summarize and compare these ten languages on ten different criterion. For example, Default more secure programming practices, Web applications development, OO-based abstraction and etc. At the end, we will give our conclusion that which languages are suitable and which are not for using in some cases. We will also provide evidence and our analysis on why some language are better than other or have advantages over the other on some criterion. 1 Introduction Since there are hundreds of programming languages existing nowadays, it is impossible and inefficient
    [Show full text]
  • 1 Intro to ML
    1 Intro to ML 1.1 Basic types Need ; after expression - 42 = ; val it = 42: int -7+1; val it =8: int Can reference it - it+2; val it = 10: int - if it > 100 then "big" else "small"; val it = "small": string Different types for each branch. What will happen? if it > 100 then "big" else 0; The type checker will complain that the two branches have different types, one is string and the other is int If with then but no else. What will happen? if 100>1 then "big"; There is not if-then in ML; must use if-then-else instead. Mixing types. What will happen? What is this called? 10+ 2.5 In many programming languages, the int will be promoted to a float before the addition is performed, and the result is 12.5. In ML, this type coercion (or type promotion) does not happen. Instead, the type checker will reject this expression. div for integers, ‘/ for reals - 10 div2; val it =5: int - 10.0/ 2.0; val it = 5.0: real 1 1.1.1 Booleans 1=1; val it = true : bool 1=2; val it = false : bool Checking for equality on reals. What will happen? 1.0=1.0; Cannot check equality of reals in ML. Boolean connectives are a bit weird - false andalso 10>1; val it = false : bool - false orelse 10>1; val it = true : bool 1.1.2 Strings String concatenation "University "^ "of"^ " Oslo" 1.1.3 Unit or Singleton type • What does the type unit mean? • What is it used for? • What is its relation to the zero or bottom type? - (); val it = () : unit https://en.wikipedia.org/wiki/Unit_type https://en.wikipedia.org/wiki/Bottom_type The boolean type is inhabited by two values: true and false.
    [Show full text]
  • Distributive Disjoint Polymorphism for Compositional Programming
    Distributive Disjoint Polymorphism for Compositional Programming Xuan Bi1, Ningning Xie1, Bruno C. d. S. Oliveira1, and Tom Schrijvers2 1 The University of Hong Kong, Hong Kong, China fxbi,nnxie,[email protected] 2 KU Leuven, Leuven, Belgium [email protected] Abstract. Popular programming techniques such as shallow embeddings of Domain Specific Languages (DSLs), finally tagless or object algebras are built on the principle of compositionality. However, existing program- ming languages only support simple compositional designs well, and have limited support for more sophisticated ones. + This paper presents the Fi calculus, which supports highly modular and compositional designs that improve on existing techniques. These im- provements are due to the combination of three features: disjoint inter- section types with a merge operator; parametric (disjoint) polymorphism; and BCD-style distributive subtyping. The main technical challenge is + Fi 's proof of coherence. A naive adaptation of ideas used in System F's + parametricity to canonicity (the logical relation used by Fi to prove co- herence) results in an ill-founded logical relation. To solve the problem our canonicity relation employs a different technique based on immediate substitutions and a restriction to predicative instantiations. Besides co- herence, we show several other important meta-theoretical results, such as type-safety, sound and complete algorithmic subtyping, and decidabil- ity of the type system. Remarkably, unlike F<:'s bounded polymorphism, + disjoint polymorphism in Fi supports decidable type-checking. 1 Introduction Compositionality is a desirable property in programming designs. Broadly de- fined, it is the principle that a system should be built by composing smaller sub- systems.
    [Show full text]
  • Bs-6026-0512E.Pdf
    THERMAL PRINTER SPEC BAS - 6026 1. Basic Features 1.) Type : PANEL Mounting or DESK top type 2.) Printing Type : THERMAL PRINT 3.) Printing Speed : 25mm / SEC 4.) Printing Column : 24 COLUMNS 5.) FONT : 24 X 24 DOT MATRIX 6.) Character : English, Numeric & Others 7.) Paper width : 57.5mm ± 0.5mm 8.) Character Size : 5times enlarge possible 9.) INTERFACE : CENTRONICS PARALLEL I/F SERIAL I/F 10.) DIMENSION : 122(W) X 90(D) X 129(H) 11.) Operating Temperature range : 0℃ - 50℃ 12.) Storage Temperature range : -20℃ - 70℃ 13.) Outlet Power : DC 12V ( 1.6 A )/ DC 5V ( 2.5 A) 14.) Application : Indicator, Scale, Factory automation equipments and any other data recording, etc.,, - 1 - 1) SERIAL INTERFACE SPECIFICATION * CONNECTOR : 25 P FEMALE PRINTER : 4 P CONNECTOR 3 ( TXD ) ----------------------- 2 ( RXD ) 2 2 ( RXD ) ----------------------- 1 ( TXD ) 3 7 ( GND ) ----------------------- 4 ( GND ) 5 DIP SWITCH BUAD RATE 1 2 3 ON ON ON 150 OFF ON ON 300 ON OFF ON 600 OFF OFF ON 1200 ON ON OFF 2400 OFF ON OFF 4800 ON OFF OFF 9600 OFF OFF OFF 19200 2) BAUD RATE SELECTION * PROTOCOL : XON / XOFF Type DIP SWITCH (4) ON : Combination type * DATA BIT : 8 BIT STOP BIT : 1 STOP BIT OFF: Complete type PARITY CHECK : NO PARITY * DEFAULT VALUE : BAUD RATE (9600 BPS) - 2 - PRINTING COMMAND * Explanation Command is composed of One Byte Control code and ESC code. This arrangement is started with ESC code which is connected by character & numeric code The control code in Printer does not be still in standardization (ESC Control Code). All printers have a code structure by themselves.
    [Show full text]