DOCSLIB.ORG

CA341 - Comparative Programming Languages Functional Programming Paradigm

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
CA341 - Comparative Programming Languages Functional Programming Paradigm Functional Programming Paradigm CA341 - Comparative Programming Languages Functional Programming Paradigm David Sinclair Functional Programming Paradigm Key Concepts of Functional Programming The key concepts of functional programming are: • Expressions • Functions • Parametric Polymorphism • Data Abstractions • Lazy Evaluation Expressions are used to compute new values from old values. Functions, which are first-class values, abstract over expressions. Functions can be passed as arguments to functions and computed as a result of other functions. A higher-order function is one that takes other functions as arguments or computed another functions as a result. Functions can be built into composite values. Functional Programming Paradigm Key Concepts of Functional Programming (2) Parametric polymorphism is when a function operates on values of a type family rather than just one type. It is fundamental to the power and expressiveness of functional languages. Data abstraction is common in most of the modern functional languages, such as ML and Haskell. Lazy evaluation relates to when an expression is evaluated. There are three different ways to define the order in which expressions are evaluated. • Eager evaluation • Normal-order evaluation • Lazy evaluation Functional Programming Paradigm Evaluation Order In eager evaluation we evaluate the actual parameters once at the point of call. The effect is to substitute the actual argument value for each occurrence of the formal parameter. In normal-order evaluation we evaluate the actual parameter only when the argument is actually needed. The effect is to substitute the actual unevaluated parameter for each occurrence of the formal parameter. Consider the function sqr n = n ∗ n invoked as sqr(m+1) where m has the value 6. Functional Programming Paradigm Evaluation Order (2) In eager evaluation we first evaluate m+1 which evaluates to 7. The value 7 is then bound to n. Evaluation n*n results in evaluating 7*7 as 49. In normal-order evaluation we first bind the unevaluated expression m+1 to n, resulting in the expression (m+1) * (m+1) that yields the expression (6+1) * (6+1), which yields 49. In the case of the sqr function, either evaluation order results in the same result though eager evaluation is more efficient as the expression (m+1) is only evaluated once. But this is not always the case! Consider the function cand b1 b2 = i f b1 then b2 else False Functional Programming Paradigm Evaluation Order (3) Suppose we invoke cand (n>0) (t/n>50) with n bound to 2 and t bound to 80. With eager evaluation n>0 yields True and t/n>50 yields False, and the function call yields False. With normal-order evaluation the function call effectively evaluates i f (2 >0) then (80/2 >50) else False which also yields False. Now suppose we invoke cand (n>0) (t/n>50) with n bound to 0 and t bound to 80. With eager evaluation n>0 yields False but the evaluation of t/n>50 fails due to a divide by zero error. Hence the function call fails. Functional Programming Paradigm Evaluation Order (4) With normal-order evaluation the function call effectively evaluates i f (0 >0) then (80/0 >50) else False which evaluate 0>0 as False. Since expression 80/0>50 does not need to be evaluated, the function call returns False. A function is strict in a particular argument if it always uses that argument. In our examples, the sqr function is strict in its argument n, whereas cand is strict in its first argument but nonstrict in its second argument. Functional Programming Paradigm Evaluation Order (5) Having an expression that evaluates differently depending on the evaluation order can be problematical. Some programming languages have an important property called the Church-Rosser Property, which states that: If an expression can be evaluated at all, it can be evaluated by consistently using normal-order evaluation. If an expression can be evaluated in several different orders (mixing eager and normal-order evaluation), then all of these evalution orders yield the same result. Haskell possesses the Church-Rosser Property, but any language that has side-effects (such as ML, C++, Java etc) does not possess the Church-Rosser Property. In practice normal-order evaluation is too inefficient as its actual parameters might be evaluated several times, all yielding the same argument. Functional Programming Paradigm Evaluation Order (6) In lazy evaluation we evaluate the actual parameter when the argument is first needed and then store its value for whenever it is subsequently needed. If the programming language possesses the Church-Rosser Property then lazy evaluation always results in the same values as normal-order evaluation. Lazy evaluation is adopted only by pure functional languages such as Haskell. Other languages (most languages!) adopt eager evaluation. An interesting effect of lazy evaluation is that we can define potentially infinite data structures since the evaluation of any expression is delayed until its value is actually needed. In Haskell we can define an infinite list of integers. The contents of the infinite list are not evaluated. The 500th element (and its preceding 499 elements) of the list is not evaluated until it is actually needed. Functional Programming Paradigm The Pragmatics of Functional Programming Languages A functional programming language is composed of many functions, which are in turn composed of simpler functions, which eventually are composed of expressions and declarations. A pure functional programming language does not use commands, proper procedures that update variables. Instead, a functional programming language gains its power and expressiveness from concepts such as higher-order functions and lazy evalution. A large functional program has a very large number of functions and managing them can be problematical. Many functional languages provide a mechanism to group functions into packages Functional Programming Paradigm Haskell Haskell was design in the 1980’s by a committee led by Simon Peyton Jones and John Hughes. It was influenced by ML (from which it took parametric polymorphism and type inference) and Miranda (from which it took lazy evaluation). Haskell is a pure functional language; no variables, sequencers or side-effects (though modelling state and input/output is possible using a concept called a monoid). The power of Haskell comes from its use of higher-order functions and lazy evaluation. Functional Programming Paradigm Haskell: Values and Types Haskell has the usual set of primitive types such as Bool, Char and numeric types (integers and floating-point). As a result of lazy evaluation, Haskell has both a bounded integer type, Int, and an unbounded integer type, Integer. Haskell also has the usual collection of composite types: tuples, algebraic types (disjoint unions), lists and functions. Recursive types can be defined directly. The most commonly used composite type in a Haskell program is the list. The type [t] are lists whose elements are of type t. [] denotes the empty list and x:xs constructs a list whose head (the first element) is x and tail (the list containing the remaining elements) is xs. Functional Programming Paradigm Haskell: Values and Types (2) Haskell has a large library of functions on lists. These functions demonstrates parametric polymorphism in Haskell. For example, head :: [t] −> t −− head xs computes the head of list xs of type t tail :: [t] −> [ t ] −− tail xs computes the tail of the list xs of type t length :: [t] −> I n t −− length xs computes the length of list xs ++ :: [t] −> [ t ] −> [ t ] −− xs ++ ys computes the concatenation of lists xs and ys All of these functions can operate on lists of any type t. Functional Programming Paradigm Haskell: Functions A function has a name and a set of parameters, each separated by a space. How the function is evaluated is defined by what follows the = symbol. This only tells part of the story of the rectangleArea function. • A function always evaluates to a value which has a type. • Each of the parameters of a function have a type. rectangleArea :: Float −> Float −> Float rectangleArea x y = x ∗ y The parameters and return type are separated by -> in the function declaration. The return type is the last item and the parameter types are the previous items. Functional Programming Paradigm Haskell: Functions (2) insert : : I n t −> [ I n t ] −> [ I n t ] insert i [] = [i] insert i (n:ns) = i f i < n then i:n:ns else n : insert i ns In an imperative language a similar procedure would insert the new element by selectively updating the existing list. In Haskell the function must compute a new list containing the new element as well as the original elements. Though the function seems to copy the entire original list, it actually only copies the “nodes” containing integer less than i. The remaining nodes are shared between list and the new list. Functional Programming Paradigm Haskell: Functions (3) Even though the original list is shared, because a functional programmer cannot manipulate the “links between the nodes”, the lists are effectively distinct. This does not only apply to lists but to any recursive type, such as trees. Haskell does not have any in-built support for arrays. This is because while a recursive type that differs by a single element can share a lot of their structure, this is not true of arrays. If a function modifies an array it would have to copy the original array (there is a Haskell library module that supports arrays). The simplest form of function construction is \I -> E, whose formal parameter is I and whose body is the expression E. Functional Programming Paradigm Haskell: Functions (4) A Haskell function call has the form E1 E2 where E1 is an expression that yields a function and E2 is an expression that yields the argument.
Load more

Recommended publications
  • CSCI 2041: Lazy Evaluation
    CSCI 2041: Lazy Evaluation Chris Kauffman Last Updated: Wed Dec 5 12:32:32 CST 2018 1 Logistics Reading Lab13: Lazy/Streams I Module Lazy on lazy Covers basics of delayed evaluation computation I Module Stream on streams A5: Calculon Lambdas/Closures I Arithmetic language Briefly discuss these as they interpreter pertain Calculon I 2X credit for assignment I 5 Required Problems 100pts Goals I 5 Option Problems 50pts I Eager Evaluation I Milestone due Wed 12/5 I Lazy Evaluation I Final submit Tue 12/11 I Streams 2 Evaluation Strategies Eager Evaluation Lazy Evaluation I Most languages employ I An alternative is lazy eager evaluation evaluation I Execute instructions as I Execute instructions only as control reaches associated expression results are needed code (call by need) I Corresponds closely to I Higher-level idea with actual machine execution advantages and disadvantages I In pure computations, evaluation strategy doesn’t matter: will produce the same results I With side-effects, when code is run matter, particular for I/O which may see different printing orders 3 Exercise: Side-Effects and Evaluation Strategy Most common place to see differences between Eager/Lazy eval is when functions are called I Eager eval: eval argument expressions, call functions with results I Lazy eval: call function with un-evaluated expressions, eval as results are needed Consider the following expression let print_it expr = printf "Printing it\n"; printf "%d\n" expr; ;; print_it (begin printf "Evaluating\n"; 5; end);; Predict results and output for both Eager and Lazy Eval strategies 4 Answers: Side-Effects and Evaluation Strategy let print_it expr = printf "Printing it\n"; printf "%d\n" expr; ;; print_it (begin printf "Evaluating\n"; 5; end);; Evaluation > ocamlc eager_v_lazy.ml > ./a.out Eager Eval # ocaml’s default Evaluating Printing it 5 Lazy Eval Printing it Evaluating 5 5 OCaml and explicit lazy Computations I OCaml’s default model is eager evaluation BUT.
    [Show full text]
  • Comparative Studies of Programming Languages; Course Lecture Notes
    Comparative Studies of Programming Languages, COMP6411 Lecture Notes, Revision 1.9 Joey Paquet Serguei A. Mokhov (Eds.) August 5, 2010 arXiv:1007.2123v6 [cs.PL] 4 Aug 2010 2 Preface Lecture notes for the Comparative Studies of Programming Languages course, COMP6411, taught at the Department of Computer Science and Software Engineering, Faculty of Engineering and Computer Science, Concordia University, Montreal, QC, Canada. These notes include a compiled book of primarily related articles from the Wikipedia, the Free Encyclopedia [24], as well as Comparative Programming Languages book [7] and other resources, including our own. The original notes were compiled by Dr. Paquet [14] 3 4 Contents 1 Brief History and Genealogy of Programming Languages 7 1.1 Introduction . 7 1.1.1 Subreferences . 7 1.2 History . 7 1.2.1 Pre-computer era . 7 1.2.2 Subreferences . 8 1.2.3 Early computer era . 8 1.2.4 Subreferences . 8 1.2.5 Modern/Structured programming languages . 9 1.3 References . 19 2 Programming Paradigms 21 2.1 Introduction . 21 2.2 History . 21 2.2.1 Low-level: binary, assembly . 21 2.2.2 Procedural programming . 22 2.2.3 Object-oriented programming . 23 2.2.4 Declarative programming . 27 3 Program Evaluation 33 3.1 Program analysis and translation phases . 33 3.1.1 Front end . 33 3.1.2 Back end . 34 3.2 Compilation vs. interpretation . 34 3.2.1 Compilation . 34 3.2.2 Interpretation . 36 3.2.3 Subreferences . 37 3.3 Type System . 38 3.3.1 Type checking . 38 3.4 Memory management .
    [Show full text]
  • Application and Interpretation
    Programming Languages: Application and Interpretation Shriram Krishnamurthi Brown University Copyright c 2003, Shriram Krishnamurthi This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 United States License. If you create a derivative work, please include the version information below in your attribution. This book is available free-of-cost from the author’s Web site. This version was generated on 2007-04-26. ii Preface The book is the textbook for the programming languages course at Brown University, which is taken pri- marily by third and fourth year undergraduates and beginning graduate (both MS and PhD) students. It seems very accessible to smart second year students too, and indeed those are some of my most successful students. The book has been used at over a dozen other universities as a primary or secondary text. The book’s material is worth one undergraduate course worth of credit. This book is the fruit of a vision for teaching programming languages by integrating the “two cultures” that have evolved in its pedagogy. One culture is based on interpreters, while the other emphasizes a survey of languages. Each approach has significant advantages but also huge drawbacks. The interpreter method writes programs to learn concepts, and has its heart the fundamental belief that by teaching the computer to execute a concept we more thoroughly learn it ourselves. While this reasoning is internally consistent, it fails to recognize that understanding definitions does not imply we understand consequences of those definitions. For instance, the difference between strict and lazy evaluation, or between static and dynamic scope, is only a few lines of interpreter code, but the consequences of these choices is enormous.
    [Show full text]
  • Control Flow
    Control Flow COMS W4115 Prof. Stephen A. Edwards Spring 2002 Columbia University Department of Computer Science Control Flow “Time is Nature’s way of preventing everything from happening at once.” Scott identifies seven manifestations of this: 1. Sequencing foo(); bar(); 2. Selection if (a) foo(); 3. Iteration while (i<10) foo(i); 4. Procedures foo(10,20); 5. Recursion foo(int i) { foo(i-1); } 6. Concurrency foo() jj bar() 7. Nondeterminism do a -> foo(); [] b -> bar(); Ordering Within Expressions What code does a compiler generate for a = b + c + d; Most likely something like tmp = b + c; a = tmp + d; (Assumes left-to-right evaluation of expressions.) Order of Evaluation Why would you care? Expression evaluation can have side-effects. Floating-point numbers don’t behave like numbers. Side-effects int x = 0; int foo() { x += 5; return x; } int a = foo() + x + foo(); What’s the final value of a? Side-effects int x = 0; int foo() { x += 5; return x; } int a = foo() + x + foo(); GCC sets a=25. Sun’s C compiler gave a=20. C says expression evaluation order is implementation-dependent. Side-effects Java prescribes left-to-right evaluation. class Foo { static int x; static int foo() { x += 5; return x; } public static void main(String args[]) { int a = foo() + x + foo(); System.out.println(a); } } Always prints 20. Number Behavior Basic number axioms: a + x = a if and only if x = 0 Additive identity (a + b) + c = a + (b + c) Associative a(b + c) = ab + ac Distributive Misbehaving Floating-Point Numbers 1e20 + 1e-20 = 1e20 1e-20 1e20 (1 + 9e-7) + 9e-7 6= 1 + (9e-7 + 9e-7) 9e-7 1, so it is discarded, however, 1.8e-6 is large enough 1:00001(1:000001 − 1) 6= 1:00001 · 1:000001 − 1:00001 · 1 1:00001 · 1:000001 = 1:00001100001 requires too much intermediate precision.
    [Show full text]
  • 210 CHAPTER 7. NAMES and BINDING Chapter 8
    210 CHAPTER 7. NAMES AND BINDING Chapter 8 Expressions and Evaluation Overview This chapter introduces the concept of the programming environment and the role of expressions in a program. Programs are executed in an environment which is provided by the operating system or the translator. An editor, linker, file system, and compiler form the environment in which the programmer can enter and run programs. Interac- tive language systems, such as APL, FORTH, Prolog, and Smalltalk among others, are embedded in subsystems which replace the operating system in forming the program- development environment. The top-level control structure for these subsystems is the Read-Evaluate-Write cycle. The order of computation within a program is controlled in one of three basic ways: nesting, sequencing, or signaling other processes through the shared environment or streams which are managed by the operating system. Within a program, an expression is a nest of function calls or operators that returns a value. Binary operators written between their arguments are used in infix syntax. Unary and binary operators written before a single argument or a pair of arguments are used in prefix syntax. In postfix syntax, operators (unary or binary) follow their arguments. Parse trees can be developed from expressions that include infix, prefix and postfix operators. Rules for precedence, associativity, and parenthesization determine which operands belong to which operators. The rules that define order of evaluation for elements of a function call are as follows: • Inside-out: Evaluate every argument before beginning to evaluate the function. 211 212 CHAPTER 8. EXPRESSIONS AND EVALUATION • Outside-in: Start evaluating the function body.
    [Show full text]
  • Exam 1 Review: Solutions Capture the Dragons
    CSCI 1101B: Introduction to Computer Science Instructor: Prof. Harmon Exam 1 Review: Solutions Capture the Dragons Boolean Expressions 1. Of the following, which are Boolean expressions? (a)2+3 Not Boolean (b)2>3 Boolean (c) num >= 2 Boolean (d) num1 = num2 Not Boolean 2. If x = 3, and x <= y evaluates to True, what values can y have? y >= 3 3. Simplify each of the following expressions: (a) my_num or True Depends on what the value of my_num is. See rules as in #5. (b) False and "Mary" or True True (c) False and ("Mary" or True) False 4. Is x =< y the same as x <= y? No. Python only recognizes the latter. The former is invalid syntax. 5. If x = 1 and y = 2, explain the following results: (a) >>> x and y # = 2 (b) >>> x or y # = 1 Python uses lazy evaluation. • The expression x and y first evaluates x. If x is equivalent to False (or empty/zero), its value is returned. Otherwise, y is evaluated and the resulting value is returned. • The expression x or y first evaluates x. If x is equivalent to True (or non-empty/nonzero), its value is returned. Otherwise, y is evaluated and the resulting value is returned. 1 CSCI 1101B: Introduction to Computer Science Exam 1 Review: Solutions Conditionals 1. What is indentation, and how is it related to the concept of a code block? Indentation is the placement of text (to the left or right). Python uses indenta- tion to associate code into groups, or blocks. 2. What is the difference between a chained conditional and a nested conditional? Chained => if, elif, else Nested => conditionals exist (are "nested") inside each other 3.
    [Show full text]
  • Top Functional Programming Languages Based on Sentiment Analysis 2021 11
    POWERED BY: TOP FUNCTIONAL PROGRAMMING LANGUAGES BASED ON SENTIMENT ANALYSIS 2021 Functional Programming helps companies build software that is scalable, and less prone to bugs, which means that software is more reliable and future-proof. It gives developers the opportunity to write code that is clean, elegant, and powerful. Functional Programming is used in demanding industries like eCommerce or streaming services in companies such as Zalando, Netflix, or Airbnb. Developers that work with Functional Programming languages are among the highest paid in the business. I personally fell in love with Functional Programming in Scala, and that’s why Scalac was born. I wanted to encourage both companies, and developers to expect more from their applications, and Scala was the perfect answer, especially for Big Data, Blockchain, and FinTech solutions. I’m glad that my marketing and tech team picked this topic, to prepare the report that is focused on sentiment - because that is what really drives people. All of us want to build effective applications that will help businesses succeed - but still... We want to have some fun along the way, and I believe that the Functional Programming paradigm gives developers exactly that - fun, and a chance to clearly express themselves solving complex challenges in an elegant code. LUKASZ KUCZERA, CEO AT SCALAC 01 Table of contents Introduction 03 What Is Functional Programming? 04 Big Data and the WHY behind the idea of functional programming. 04 Functional Programming Languages Ranking 05 Methodology 06 Brand24
    [Show full text]
  • CS1101S Studio Session Week 11: Stream
    Welcome CS1101S Studio Session Week 11: Stream Niu Yunpeng [email protected] October 30, 2018 Niu Yunpeng CS1101S Studio Week 11 October 30, 2018 1 / 27 Overview 1 Lazy evaluation Computational model Function application 2 Stream Delayed evaluation Stream programming Niu Yunpeng CS1101S Studio Week 11 October 30, 2018 2 / 27 Lazy Evaluation Computational model Computational model is a useful guideline for us to understand how the interpreter works. Computational model may vary depending on programming language and the runtime system used. In CS1101S, we introduce two computational models: substitution model and environment model. What to expect In the coming weeks, these two models will still be valid. Niu Yunpeng CS1101S Studio Week 11 October 30, 2018 3 / 27 Lazy Evaluation Substitution model For stateless programming only: Evaluate all actual arguments; Replace all formal parameters with their actual arguments; Apply each statement in the function body (and get the return value); Repeat the first 3 steps until done. Niu Yunpeng CS1101S Studio Week 11 October 30, 2018 4 / 27 Lazy Evaluation Environment model For stateful programming: Each frame contains a series of bindings of names and values. The value of a variable depends on its environment, a sequence of frames up to the global frame. Each function call will create a new frame and extend its enclosing environment. Niu Yunpeng CS1101S Studio Week 11 October 30, 2018 5 / 27 Lazy Evaluation Function in JavaScript Function in JavaScript is a first-class citizen (object). They have a call method. The call method is triggered when this function is applied. Function application When a function is applied, “this” is prepanded to the list of parameters.
    [Show full text]
  • Monads for Functional Programming
    Monads for functional programming Philip Wadler, University of Glasgow? Department of Computing Science, University of Glasgow, G12 8QQ, Scotland ([email protected]) Abstract. The use of monads to structure functional programs is de- scribed. Monads provide a convenient framework for simulating effects found in other languages, such as global state, exception handling, out- put, or non-determinism. Three case studies are looked at in detail: how monads ease the modification of a simple evaluator; how monads act as the basis of a datatype of arrays subject to in-place update; and how monads can be used to build parsers. 1 Introduction Shall I be pure or impure? The functional programming community divides into two camps. Pure lan- guages, such as Miranda0 and Haskell, are lambda calculus pure and simple. Impure languages, such as Scheme and Standard ML, augment lambda calculus with a number of possible effects, such as assignment, exceptions, or continu- ations. Pure languages are easier to reason about and may benefit from lazy evaluation, while impure languages offer efficiency benefits and sometimes make possible a more compact mode of expression. Recent advances in theoretical computing science, notably in the areas of type theory and category theory, have suggested new approaches that may integrate the benefits of the pure and impure schools. These notes describe one, the use of monads to integrate impure effects into pure functional languages. The concept of a monad, which arises from category theory, has been applied by Moggi to structure the denotational semantics of programming languages [13, 14]. The same technique can be applied to structure functional programs [21, 23].
    [Show full text]
  • Haskell Communities and Activities Report
    Haskell Communities and Activities Report http://tinyurl.com/haskcar Thirty Fourth Edition — May 2018 Mihai Maruseac (ed.) Chris Allen Christopher Anand Moritz Angermann Francesco Ariis Heinrich Apfelmus Gershom Bazerman Doug Beardsley Jost Berthold Ingo Blechschmidt Sasa Bogicevic Emanuel Borsboom Jan Bracker Jeroen Bransen Joachim Breitner Rudy Braquehais Björn Buckwalter Erik de Castro Lopo Manuel M. T. Chakravarty Eitan Chatav Olaf Chitil Alberto Gómez Corona Nils Dallmeyer Tobias Dammers Kei Davis Dimitri DeFigueiredo Richard Eisenberg Maarten Faddegon Dennis Felsing Olle Fredriksson Phil Freeman Marc Fontaine PÁLI Gábor János Michał J. Gajda Ben Gamari Michael Georgoulopoulos Andrew Gill Mikhail Glushenkov Mark Grebe Gabor Greif Adam Gundry Jennifer Hackett Jurriaan Hage Martin Handley Bastiaan Heeren Sylvain Henry Joey Hess Kei Hibino Guillaume Hoffmann Graham Hutton Nicu Ionita Judah Jacobson Patrik Jansson Wanqiang Jiang Dzianis Kabanau Nikos Karagiannidis Anton Kholomiov Oleg Kiselyov Ivan Krišto Yasuaki Kudo Harendra Kumar Rob Leslie David Lettier Ben Lippmeier Andres Löh Rita Loogen Tim Matthews Simon Michael Andrey Mokhov Dino Morelli Damian Nadales Henrik Nilsson Wisnu Adi Nurcahyo Ulf Norell Ivan Perez Jens Petersen Sibi Prabakaran Bryan Richter Herbert Valerio Riedel Alexey Radkov Vaibhav Sagar Kareem Salah Michael Schröder Christian Höner zu Siederdissen Ben Sima Jeremy Singer Gideon Sireling Erik Sjöström Chris Smith Michael Snoyman David Sorokin Lennart Spitzner Yuriy Syrovetskiy Jonathan Thaler Henk-Jan van Tuyl Tillmann Vogt Michael Walker Li-yao Xia Kazu Yamamoto Yuji Yamamoto Brent Yorgey Christina Zeller Marco Zocca Preface This is the 34th edition of the Haskell Communities and Activities Report. This report has 148 entries, 5 more than in the previous edition.
    [Show full text]
  • The Scala Programming Language
    The Scala Programming Language Mooly Sagiv Slides taken from Martin Odersky (EPFL) Donna Malayeri (CMU) Hila Peleg (TAU) Modern Functional Programming • Higher order • Modules • Pattern matching • Statically typed with type inference • Two viable alternatives • Haskel • Pure lazy evaluation and higher order programming leads to Concise programming • Support for domain specific languages • I/O Monads • Type classes • OCaml • Encapsulated side-effects via references Then Why aren’t FP adapted? • Education • Lack of OO support • Subtyping increases the complexity of type inference • Programmers seeks control on the exact implementation • Imperative programming is natural in certain situations Why Scala? (Coming from OCaml) • Runs on the JVM/.NET • Can use any Java code in Scala • Combines functional and imperative programming in a smooth way • Effective library • Inheritance • General modularity mechanisms The Java Programming Language • Designed by Sun 1991-95 • Statically typed and type safe • Clean and Powerful libraries • Clean references and arrays • Object Oriented with single inheritance • Interfaces with multiple inhertitence • Portable with JVM • Effective JIT compilers • Support for concurrency • Useful for Internet Java Critique • Downcasting reduces the effectiveness of static type checking • Many of the interesting errors caught at runtime • Still better than C, C++ • Huge code blowouts • Hard to define domain specific knowledge • A lot of boilerplate code • Sometimes OO stands in our way • Generics only partially helps Why
    [Show full text]
  • Pure Quick Reference
    Pure Quick Reference Albert Graf¨ April 15, 2018 Abstract This is a quick reference guide to the Pure programming language for the impa- tient. It briefly summarizes all important language constructs and gives a few basic examples, so that seasoned programmers can pick up the language at a glance and start hacking away as quickly as possible. Copyright © 2009-2018 Albert Gräf. Permission is granted to copy, distribute and/or modify this docu- ment under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation. See http://www.gnu.org/copyleft/fdl.html. The latest version of this document can be found at https://agraef.github.io/pure-lang/quickref/pure-quickref.pdf. Contents 1 Introduction 3 1.1 Background and Recommended Reading . 3 1.2 Getting Started . 4 2 Lexical Matters 5 3 Expressions 6 3.1 Primary Expressions . 7 3.2 Function Applications . 9 3.3 Operators . 11 3.4 Predefined Operators . 13 3.5 Patterns . 15 3.6 Conditional Expressions . 18 3.7 Block Expressions . 19 3.8 Lexical Scoping . 21 3.9 Comprehensions . 22 3.10 Special Forms . 23 1 4 Definitions 26 4.1 The Global Scope . 26 4.2 Rule Syntax . 27 4.3 Function Definitions . 29 4.4 Variable Definitions . 33 4.5 Constant Definitions . 33 4.6 Type Definitions . 34 4.7 Macro Definitions . 37 5 Programs and Modules 38 5.1 Modules . 38 5.2 Namespaces . 39 5.3 Private Symbols . 42 5.4 Hierarchical Namespaces . 42 6 C Interface 43 7 The Interpreter 45 7.1 Running the Interpreter .
    [Show full text]