DOCSLIB.ORG

CS345H: Programming Languages Lecture 19: Haskell Overview

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
CS345H: Programming Languages Lecture 19: Haskell Overview Overview CS345H: Programming Languages I Today: Look at the Haskell programming language I Like LISP, Haskell is a functional language Lecture 19: Haskell I Unlike LISP, Haskell is statically typed and has an expressive type system Thomas Dillig I Integrates many concepts we looked at: static typing, type inference, polymorphism, higher-order functions, . I At the cutting edge of PL research: designed by researchers, lots of new research done in the context of Haskell Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 1/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 2/33 Little Bit of History History of Haskell I Designed in the early 90’s by a committee of researchers I Haskell borrows ideas from both LISP and ML I Goal was to unify research efforts in pure, lazy functional languages I Like LISP and ML, functional language I Feeling was that widespread use of lazy functional languages was being hampered by lack of standard language I Like ML, has a strong, expressive static type I Goal of the committee was to design a lazy functional system language that would become standard I But also different from I People who played key role in designing Haskell: Simon both in some ways: e.g., Peyton Jones (Microsoft Research), Philip Wadler lazy functional language (Edinburgh), Paul Hudak (Yale), John Hughes (Chalmers) Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 3/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 4/33 Why Called Haskell? Overview of Haskell Features I The Haskell programming language is named after logician Haskell B. Curry I Lazy evaluation I Haskell curry well-known for Curry-Howard isopmorphism I Expressive static type system I Curry-Howard isomorphism sheds light on relationship between I Polymorphism and type classes constructive logic and functional programming languages I Tagged unions, type constructors I Specifically, it says: I Pattern matching 1. Propositions are types I List comprehension 2. Proofs are programs 3. Proof checking is type checking Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 5/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 6/33 1 Lazy vs. Strict Programming Languages Example of Lazy vs. Eager I Haskell is different from many other functional languages in that it’s lazy I Suppose you pass a divergent (i.e., non-terminating) expression as an argument to a function I Lazy (or call-by-need, non-strict) languages delay evaluation of an expression until its value is actually required I In an eager language, the program will definitely not terminate I In contrast, eager (or strict, call-by-value) languages, an I In a lazy language, the program will terminate if the value of expression is evaluated as soon as it is bound to a variable, that argument is not needed in the called function regardless of whether the variable is used or not I There are both advantages and disadvantages of lazy I The default behavior in many languages used today is eager evaluation evaluation: Java, C, C++, ML, Python, Lisp, Scheme . Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 7/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 8/33 Advantages and Disadvantages of Lazy Evaluation Expressive Static Type System Advantages of Lazy Evaluation: I Haskell is a statically typed language with a sound type system I Unused arguments are not evaluated – can be a big win if evaluation of expression is expensive I Does not allow ways to subvert the type system, such as casting I Can avoid divergent or buggy bahevior in some cases I Thus, if the Haskell compiler assigns type T to expression e, I Can create infinite data structures run-time value of e will be in the set of values defined by T Disadvantages of Lazy Evaluation: I Can be difficult to predict program behavior I Haskell performs type inference, so you don’t have to explicitly annotate types of expressions I Doesn’t work well in the presence of side effects I Furthermore, Haskell has polymorphism: Types of variables I Even in purely functional languages, things like IO become can contain (universally-quantified) type variables much more difficult Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 9/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 10/33 Example of Polymorphism in Haskell Another Example I Let’s look at a more interesting example: map f [] = [] I Consider the id function in Haskell: let id x = x map f (x:xs) = f x : map f xs I This function has the inferred polymorphic type a -> a I Here, we define a higher-order map function which applies a function f to every element in the list I For any type a, if the value of the input is a, the output is also of type a I This function definition illustrates pattern matching in Haskell: here, we pattern match on the second argument I The Haskell type a -> a is the same as α.α α ∀ → I First line: if the input list is empty, then return the empty list I Second line corresponds to case where list has at least one element Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 11/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 12/33 2 Example, cont. Example, cont. map f [] = [] map f [] = [] map f (x:xs) = f x : map f xs map f (x:xs) = f x : map f xs I By using the notation (x:xs), we bind first element of input I Haskell compiler infers type of this function to be: list to x and rest of the list to xs (a -> b) -> [a] -> [b] I Second line: Applies function f to head x of the list I Again, this is a polymorphic type I Then, recursively invokes map with function f on the I Says: Given any function of type a -> b and a list of values remainder xs of the list of type a, return value is a list of values of type b I Finally, returns a list which is the concatanation of f x and I Here, a and b are (implicitly) universally-quantified type result of recursive call variables Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 13/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 14/33 Type Classes Type Class Example I Consider the Haskell function: f x = x*2 I The type of the function f x = x*2 in Haskell is actually: I What is the type of this function? (Num a) => a -> a I We can’t give it the polymorphic type a -> a because it only I Says: For any type a that belongs to type class Num, function works on types for which multiplication is defined f takes a value of type a and return a value of type a I But assigning type Integer -> Integer also too restrictive I Since integers, floats etc. all belong to the Num type class, this because works for floats or other types for which * is defined type is very general! I Haskell solves this problem through type classes Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 15/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 16/33 Programming with Type Classes Programming with Type Classes, cont. I To use this feature of Haskell, first need to declare type classes I Then, we declare instances of a type class I A type class is simply a set of types that support a common set of operations I Example: instance Num Int where I To define the type class, declare the common operations and a+b = intPlus a b give type class a name a*b = intTimes a b ... I Example: I Instance declarations show how Num operations are class Num a where implemented for a particular type (+) :: a-> a -> a (*) :: a -> a -> a ... I Using type class and instance declarations, Haskell can infer general and useful types such as: I This declares a type class called Num that supports operations (Num a) => a -> a + and * Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 17/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 18/33 3 Algebraic Data Types Tagged Union Example data Student = BS (Name, Dept) | MS (Name, Dept, Area) I Another useful feature of Haskell is algebraic data types, also I Here, BS and MS are constructors called tagged unions or discriminated unions I The BS constructor must be applied to a pair consisting of a I Suppose we want to have a type to represent students name and department I For undergraduates, we want to track their name and I The MS constructor must be applied to tuple consisting of department name, department, and specialty I For masters students, we want to track their name, I Thus, Student is really a union of the two types Name*Dept department, and specialty and Name*Dept*Area I In Haskell, you can have a data type to represent both I Here, A*B is a product type which corresponds to type of undergraduate and masters students: tuple whose elements are of type A and B Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 19/33 Thomas Dillig, CS345H: Programming Languages Lecture 19: Haskell 20/33 Pattern Matching on Data Types Recursive Data Types I Now, suppose we want to write a name function that gives the name of any student I Data types in Haskell can also be recursive I We can conveniently do this in Haskell through I i.e., data type being declared can apprear as arguments of pattern-matching: type constructors name (BS(n,d)) = n I Example: name (MS(n,d, a)) = n data Tree = Leaf Int | Node (Tree, Tree) I Haskell compiler will infer type of name as Student -> Name I Here is how you would write a function in Haskell that checks I This is another example of pattern matching in Haskell if a given integer is in the tree: inTree x (Leaf y) = x==y I First line matches on students with type constructor BS
Load more

Recommended publications
  • GHC Reading Guide
    GHC Reading Guide - Exploring entrances and mental models to the source code - Takenobu T. Rev. 0.01.1 WIP NOTE: - This is not an official document by the ghc development team. - Please refer to the official documents in detail. - Don't forget “semantics”. It's very important. - This is written for ghc 9.0. Contents Introduction 1. Compiler - Compilation pipeline - Each pipeline stages - Intermediate language syntax - Call graph 2. Runtime system 3. Core libraries Appendix References Introduction Introduction Official resources are here GHC source repository : The GHC Commentary (for developers) : https://gitlab.haskell.org/ghc/ghc https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary GHC Documentation (for users) : * master HEAD https://ghc.gitlab.haskell.org/ghc/doc/ * latest major release https://downloads.haskell.org/~ghc/latest/docs/html/ * version specified https://downloads.haskell.org/~ghc/9.0.1/docs/html/ The User's Guide Core Libraries GHC API Introduction The GHC = Compiler + Runtime System (RTS) + Core Libraries Haskell source (.hs) GHC compiler RuntimeSystem Core Libraries object (.o) (libHsRts.o) (GHC.Base, ...) Linker Executable binary including the RTS (* static link case) Introduction Each division is located in the GHC source tree GHC source repository : https://gitlab.haskell.org/ghc/ghc compiler/ ... compiler sources rts/ ... runtime system sources libraries/ ... core library sources ghc/ ... compiler main includes/ ... include files testsuite/ ... test suites nofib/ ... performance tests mk/ ... build system hadrian/ ... hadrian build system docs/ ... documents : : 1. Compiler 1. Compiler Compilation pipeline 1. compiler The GHC compiler Haskell language GHC compiler Assembly language (native or llvm) 1. compiler GHC compiler comprises pipeline stages GHC compiler Haskell language Parser Renamer Type checker Desugarer Core to Core Core to STG STG to Cmm Assembly language Cmm to Asm (native or llvm) 1.
    [Show full text]
  • Haskell-Like S-Expression-Based Language Designed for an IDE
    Department of Computing Imperial College London MEng Individual Project Haskell-Like S-Expression-Based Language Designed for an IDE Author: Supervisor: Michal Srb Prof. Susan Eisenbach June 2015 Abstract The state of the programmers’ toolbox is abysmal. Although substantial effort is put into the development of powerful integrated development environments (IDEs), their features often lack capabilities desired by programmers and target primarily classical object oriented languages. This report documents the results of designing a modern programming language with its IDE in mind. We introduce a new statically typed functional language with strong metaprogramming capabilities, targeting JavaScript, the most popular runtime of today; and its accompanying browser-based IDE. We demonstrate the advantages resulting from designing both the language and its IDE at the same time and evaluate the resulting environment by employing it to solve a variety of nontrivial programming tasks. Our results demonstrate that programmers can greatly benefit from the combined application of modern approaches to programming tools. I would like to express my sincere gratitude to Susan, Sophia and Tristan for their invaluable feedback on this project, my family, my parents Michal and Jana and my grandmothers Hana and Jaroslava for supporting me throughout my studies, and to all my friends, especially to Harry whom I met at the interview day and seem to not be able to get rid of ever since. ii Contents Abstract i Contents iii 1 Introduction 1 1.1 Objectives ........................................ 2 1.2 Challenges ........................................ 3 1.3 Contributions ...................................... 4 2 State of the Art 6 2.1 Languages ........................................ 6 2.1.1 Haskell ....................................
    [Show full text]
  • A Formal Methodology for Deriving Purely Functional Programs from Z Specifications Via the Intermediate Specification Language Funz
    Louisiana State University LSU Digital Commons LSU Historical Dissertations and Theses Graduate School 1995 A Formal Methodology for Deriving Purely Functional Programs From Z Specifications via the Intermediate Specification Language FunZ. Linda Bostwick Sherrell Louisiana State University and Agricultural & Mechanical College Follow this and additional works at: https://digitalcommons.lsu.edu/gradschool_disstheses Recommended Citation Sherrell, Linda Bostwick, "A Formal Methodology for Deriving Purely Functional Programs From Z Specifications via the Intermediate Specification Language FunZ." (1995). LSU Historical Dissertations and Theses. 5981. https://digitalcommons.lsu.edu/gradschool_disstheses/5981 This Dissertation is brought to you for free and open access by the Graduate School at LSU Digital Commons. It has been accepted for inclusion in LSU Historical Dissertations and Theses by an authorized administrator of LSU Digital Commons. For more information, please contact [email protected]. INFORMATION TO USERS This manuscript has been reproduced from the microfilm master. UMI films the text directly from the original or copy submitted. Thus, some thesis and dissertation copies are in typewriter face, while others may be from any type of computer printer. H ie quality of this reproduction is dependent upon the quality of the copy submitted. Broken or indistinct print, colored or poor quality illustrations and photographs, print bleedthrough, substandardm argins, and improper alignment can adversely affect reproduction. In the unlikely, event that the author did not send UMI a complete manuscript and there are missing pages, these will be noted. Also, if unauthorized copyright material had to be removed, a note will indicate the deletion. Oversize materials (e.g., maps, drawings, charts) are reproduced by sectioning the original, beginning at the upper left-hand comer and continuing from left to right in equal sections with small overlaps.
    [Show full text]
  • The Logic of Demand in Haskell
    Under consideration for publication in J. Functional Programming 1 The Logic of Demand in Haskell WILLIAM L. HARRISON Department of Computer Science University of Missouri Columbia, Missouri RICHARD B. KIEBURTZ Pacific Software Research Center OGI School of Science & Engineering Oregon Health & Science University Abstract Haskell is a functional programming language whose evaluation is lazy by default. However, Haskell also provides pattern matching facilities which add a modicum of eagerness to its otherwise lazy default evaluation. This mixed or “non-strict” semantics can be quite difficult to reason with. This paper introduces a programming logic, P-logic, which neatly formalizes the mixed evaluation in Haskell pattern-matching as a logic, thereby simplifying the task of specifying and verifying Haskell programs. In P-logic, aspects of demand are reflected or represented within both the predicate language and its model theory, allowing for expressive and comprehensible program verification. 1 Introduction Although Haskell is known as a lazy functional language because of its default eval- uation strategy, it contains a number of language constructs that force exceptions to that strategy. Among these features are pattern-matching, data type strictness annotations and the seq primitive. The semantics of pattern-matching are further enriched by irrefutable pattern annotations, which may be embedded within pat- terns. The interaction between Haskell’s default lazy evaluation and its pattern- matching is surprisingly complicated. Although it offers the programmer a facility for fine control of demand (Harrison et al., 2002), it is perhaps the aspect of the Haskell language least well understood by its community of users. In this paper, we characterize the control of demand first in a denotational semantics and then in a verification logic called “P-logic”.
    [Show full text]
  • Functional Baby Talk: Analysis of Code Fragments from Novice Haskell Programmers
    Functional Baby Talk: Analysis of Code Fragments from Novice Haskell Programmers Jeremy Singer and Blair Archibald School of Computing Science University of Glasgow UK [email protected] [email protected] What kinds of mistakes are made by novice Haskell developers, as they learn about functional pro- gramming? Is it possible to analyze these errors in order to improve the pedagogy of Haskell? In 2016, we delivered a massive open online course which featured an interactive code evaluation en- vironment. We captured and analyzed 161K interactions from learners. We report typical novice developer behavior; for instance, the mean time spent on an interactive tutorial is around eight min- utes. Although our environment was restricted, we gain some understanding of Haskell novice er- rors. Parenthesis mismatches, lexical scoping errors and do block misunderstandings are common. Finally, we make recommendations about how such beginner code evaluation environments might be enhanced. 1 Introduction The Haskell programming language [14] has acquired a reputation for being difficult to learn. In his presentation on the origins of Haskell [23] Peyton Jones notes that, according to various programming language popularity metrics, Haskell is much more frequently discussed than it is used for software implementation. The xkcd comic series features a sarcastic strip on Haskell’s side-effect free property [21]. Haskell code is free from side-effects ‘because no-one will ever run it.’ In 2016, we ran the first instance of a massive open online course (MOOC) at Glasgow, providing an introduction to functional programming in Haskell. We received many items of learner feedback that indicated difficulty in learning Haskell.
    [Show full text]
  • Haskell As a Higher Order Structural Hardware Description Language
    Haskell as a higher order structural hardware description language Master's thesis by Matthijs Kooijman December 9, 2009 Committee: Dr. Ir. Jan Kuper Ir. Marco Gerards Ir. Bert Molenkamp Dr. Ir. Sabih Gerez Computer Architecture for Embedded Systems Faculty of EEMCS University of Twente Abstract Functional hardware description languages have been around for a while, but never saw adoption on a large scale. Even though advanced features like higher order functions and polymorphism could enable very natural parametrization of hardware descriptions, the conventional hardware description languages VHDL and Verilog are still most widely used. Cλash is a new functional hardware description language using Haskell's syntax and semantics. It allows structurally describing synchronous hardware, using normal Haskell syntax combined with a selection of built-in functions for operations like addition or list operations. More complex constructions like higher order functions and polymorphism are fully supported. Cλash supports stateful descriptions through explicit descriptions of a function's state. Every function accepts an argument containing its current state and returns its updated state as a part of its result. This means every function is called exactly once for each cycle, limiting Cλash to synchronous systems with a single clock domain. A prototype compiler for Cλash has been implemented that can generate an equivalent VHDL description (using mostly structural VHDL). The prototype uses the front-end (parser, type-checker, desugarer) ofthe existing GHC Haskell compiler. This front-end generates a Core version of the description, which is a very small typed functional language. A normalizing system of transformations brings this Core version into a normal form that has any complex parts (higher order functions, polymorphism, complex nested structures) removed.
    [Show full text]
  • A Proxima-Based Haskell IDE
    Thesis for the degree of Master of Science A Proxima-based Haskell IDE Gerbo Engels October 2008 INF/SCR-07-93 Supervisor: Center for Software Technology prof. dr. S. Doaitse Swierstra Dept. of Information and Computing Sciences Universiteit Utrecht Daily supervisor: Utrecht, The Netherlands dr. Martijn M. Schrage Abstract Proxima is a generic presentation-oriented editor for structured documents, in which a graphical presentation of the document can be edited directly (WYSIWYG editing), resulting in changes in the underlying structure of the document. Proxima understands the document structure and it supports direct edit operations on the document structure as well. A Proxima instantiation uses a parser to get the document structure; modern compilers have parsers as well, which may be accessible through an API. Using the parser of an external compiler as the Proxima parser saves one from writing a new parser. Furthermore, the parse tree of a com- piler can contain extra information that is useful to display in an editor, such as type information of a Haskell compiler in a Haskell source code editor. This thesis aims to use the parser of an external compiler as the Proxima parser. We identify and solve problems that arise when using the parser of an external compiler as the Proxima parser, and two Haskell editors are developed as Proxima instantiations that use the parser of GHC or EHC respectively. i ii Contents 1 Introduction 1 1.1 Thesis Overview.........................................2 I The State of the World3 2 Existing Haskell Editors and IDE’s5 2.1 Visual Haskell...........................................6 2.2 Eclipse Plug-in...........................................7 2.3 Haskell Editors Written in Haskell...............................8 2.4 Other Editors or Tools.....................................
    [Show full text]
  • Haskell High Performance Programming Table of Contents
    Haskell High Performance Programming Table of Contents Haskell High Performance Programming Credits About the Author About the Reviewer www.PacktPub.com eBooks, discount offers, and more Why subscribe? Preface What this book covers What you need for this book Who this book is for Conventions Reader feedback Customer support Downloading the example code Downloading the color images of this book Errata Piracy Questions 1. Identifying Bottlenecks Meeting lazy evaluation Writing sum correctly Weak head normal form Folding correctly Memoization and CAFs Constant applicative form Recursion and accumulators The worker/wrapper idiom Guarded recursion Accumulator parameters Inspecting time and space usage Increasing sharing and minimizing allocation Compiler code optimizations Inlining and stream fusion Polymorphism performance Partial functions Summary 2. Choosing the Correct Data Structures Annotating strictness and unpacking datatype fields Unbox with UNPACK Using anonymous tuples Performance of GADTs and branching Handling numerical data Handling binary and textual data Representing bit arrays Handling bytes and blobs of bytes Working with characters and strings Using the text library Builders for iterative construction Builders for strings Handling sequential data Using difference lists Difference list performance Difference list with the Writer monad Using zippers Accessing both ends fast with Seq Handling tabular data Using the vector package Handling sparse data Using the containers package Using the unordered-containers package Ephemeral
    [Show full text]
  • Trace-Based Just-In-Time Compilation for Lazy Functional Programming Languages
    Trace-based Just-in-time Compilation for Lazy Functional Programming Languages Thomas Schilling School of Computing University of Kent at Canterbury A thesis submitted for the degree of Doctor of Philosophy April 2013 i Abstract This thesis investigates the viability of trace-based just-in-time (JIT) compilation for optimising programs written in the lazy functional programming language Haskell. A trace-based JIT compiler optimises only execution paths through the program, which is in contrast to method-based compilers that optimise complete functions at a time. The potential advantages of this approach are shorter compilation times and more natural interprocedural optimisation. Trace-based JIT compilers have previously been used successfully to optimise programs written in dynamically typed languages such as JavaScript, Python, or Lua, but also statically typed languages like Java or the Common Language Runtime (CLR). Lazy evalu- ation poses implementation challenges similar to those of dynamic languages, so trace-based JIT compilation promises to be a viable ap- proach. In this thesis we focus on program performance, but having a JIT compiler available can simplify the implementation of features like runtime inspection and mobile code. We implemented Lambdachine, a trace-based JIT compiler which im- plements most of the pure subset of Haskell. We evaluate Lamb- dachine's performance using a set of micro-benchmarks and a set of larger benchmarks from the \spectral" category of the Nofib bench- mark suite. Lambdachine's performance (excluding garbage collection overheads) is generally about 10 to 20 percent slower than GHC on statically optimised code. We identify the two main causes for this slow-down: trace selection and impeded heap allocation optimisations due to unnecessary thunk updates.
    [Show full text]
  • Introduction to Haskell
    Advanced Topics in Programming Languages Lecture 2 - Introduction to Haskell Ori Bar El Maxim Finkel 01/11/17 1 History Haskell is a lazy, committee designed, pure functional programming language that started development in the late 1980’s. Haskell derives its name from Haskell Curry, a mathematician and logician. The goals of the Haskell language were formally defined by its designers, and they stated that Haskell should: 1. Be suitable for teaching, research, and applications, including building 2. Be completely described via the publication of a formal syntax and se- mantics. 3. Be freely available. 4. Be usable as a basis for further language research. 5. Be based on ideas that enjoy a wide consensus. 6. Reduce unnecessary diversity in functional programming languages. Development of the language began shortly after the 1988 meeting, but it was not until April 1, 1990 that the first working version of Haskell, Haskell 1.0, was released. From 1990 to 1999 many incremental versions of Haskell were released and in 1999 the Haskell Committee decided that a formalized and stable version of the language needed to be released. They decided to call this standard version of the language Haskell 98. The reasoning behind creating a Haskell standard was so the language could be used in teaching environments and books could be written about it. Haskell 98 did not fully stabilize until 2002. Haskell recently released a new standardized version called Haskell 2010. This update includes all the changes in the language since 2002 repackaged with up-to-date documentation in the newest version of the Haskell Report.
    [Show full text]
  • Csci 450: Org. of Programming Languages Basic Haskell Functional Programming
    CSci 450: Org. of Programming Languages Basic Haskell Functional Programming H. Conrad Cunningham 26 October 2017 Contents 2 Basic Haskell Functional Programming 2 2.1 Chapter Introduction . 2 2.2 Defining Our First Haskell Functions . 2 2.2.1 Factorial function specification . 2 2.2.2 Factorial function using if-then-else: fact1 . 3 2.2.3 Factorial function using guards: fact2 ........... 5 2.2.4 Factorial function using pattern matching: fact3 and fact4 6 2.2.5 Factorial function using a built-in library function: fact5 7 2.3 Using the Glasgow Haskell Compiler (GHC) . 7 2.4 Surveying the Basic Types . 10 2.4.1 Integers: Int and Integer . 10 2.4.2 Floating point numbers: Float and Double . 10 2.4.3 Booleans: Bool ........................ 11 2.4.4 Characters: Char ....................... 11 2.4.5 Functions: t1 -> t2 ..................... 11 2.4.6 Tuples: (t1,t2,...,tn) . 12 2.4.7 Lists: [t] ........................... 13 2.4.8 Strings: String ........................ 13 2.5 Using Top-Down Stepwise Refinement . 14 2.5.1 Developing a square root package . 14 2.5.2 Making the package a Haskell module . 16 2.5.3 Top-down stepwise refinement . 16 2.6 Using Data Abstraction . 17 2.6.1 Rational number arithmetic . 17 2.6.2 Rational number data representation . 19 2.6.3 Modularization . 21 2.6.4 Alternative rational number data representation . 22 2.7 Modular Design and Programming . 25 2.7.1 Information-hiding modules . 25 2.7.2 Interfaces . 26 1 2.7.3 Haskell information-hiding modules . 26 2.7.4 Invariants .
    [Show full text]
  • Ready, Set, Verify! Applying Hs-To-Coq to Real-World Haskell Code
    Ready, Set, Verify! Applying hs-to-coq to real-world Haskell code JOACHIM BREITNER, University of Pennsylvania, USA ANTAL SPECTOR-ZABUSKY, University of Pennsylvania, USA YAO LI, University of Pennsylvania, USA CHRISTINE RIZKALLAH, University of New South Wales, Australia JOHN WIEGLEY, BAE Systems, USA STEPHANIE WEIRICH, University of Pennsylvania, USA Good tools can bring mechanical verification to programs written in mainstream functional languages. Weuse hs-to-coq to translate significant portions of Haskell’s containers library into Coq, and verify it against specifications that we derive from a variety of sources including type class laws, the library’s testsuite,and interfaces from Coq’s standard library. Our work shows that it is feasible to verify mature, widely-used, highly optimized, and unmodified Haskell code. We also learn more about the theory of weight-balanced trees, extend hs-to-coq to handle partiality, and – since we found no bugs – attest to the superb quality of well-tested functional code. CCS Concepts: • Software and its engineering → Software verification; Additional Key Words and Phrases: Coq, Haskell, verification 1 INTRODUCTION What would it take to tempt functional programmers to verify their code? Certainly, better tools would help. We see that functional programmers who use dependently- typed languages or proof assistants, such as Coq [The Coq development team 2016], Agda [Bove et al. 2009], Idris [Brady 2017], and Isabelle [Nipkow et al. 2002], do verify their code, since their tools allow it. However, adopting these platforms means rewriting everything from scratch. What about the verification of existing code, such as libraries written in mature languages like Haskell? Haskell programmers can reach for LiquidHaskell [Vazou et al.
    [Show full text]