DOCSLIB.ORG

Scala-Language.Pdf

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

Scala Language #scala Table of Contents About 1 Chapter 1: Getting started with Scala Language 2 Remarks 2 Versions 2 Examples 3 Hello World by Defining a 'main' Method 3 Hello World by extending App 4 Delayed Initialization 4 Delayed Initialization 4 Hello World as a script 5 Using the Scala REPL 5 Scala Quicksheet 6 Chapter 2: Annotations 8 Syntax 8 Parameters 8 Remarks 8 Examples 8 Using an Annotation 8 Annotating the main constructor 8 Creating Your Own Annotations 9 Chapter 3: Best Practices 11 Remarks 11 Examples 11 Keep it simple 11 Don't pack too much in one expression. 11 Prefer a Functional Style, Reasonably 12 Chapter 4: Case Classes 13 Syntax 13 Examples 13 Case Class Equality 13 Generated Code Artifacts 13 Case Class Basics 15 Case Classes and Immutabilty 15 Create a Copy of an Object with Certain Changes 16 Single Element Case Classes for Type Safety 16 Chapter 5: Classes and Objects 18 Syntax 18 Examples 18 Instantiate Class Instances 18 Instantiating class with no parameter: {} vs () 19 Singleton & Companion Objects 20 Singleton Objects 20 Companion Objects 20 Objects 21 Instance type checking 21 Constructors 23 Primary Constructor 23 Auxiliary Constructors 24 Chapter 6: Collections 25 Examples 25 Sort A List 25 Create a List containing n copies of x 26 List and Vector Cheatsheet 26 Map Collection Cheatsheet 27 Map and Filter Over A Collection 28 Map 28 Multiplying integer numbers by two 28 Filter 28 Checking pair numbers 28 More Map and Filter examples 29 Introduction to Scala Collections 29 Traversable types 30 Fold 31 Foreach 32 Reduce 32 Chapter 7: Continuations Library 34 Introduction 34 Syntax 34 Remarks 34 Examples 34 Callbacks are Continutations 34 Creating Functions That Take Continuations 35 Chapter 8: Currying 37 Syntax 37 Examples 37 A configurable multiplier as a curried function 37 Multiple parameter groups of different types, currying parameters of arbitrary positions 37 Currying a function with a single parameter group 37 Currying 38 Currying 38 When to use Currying 39 A real world use of Currying. 40 Chapter 9: Dependency Injection 42 Examples 42 Cake Pattern with inner implementation class. 42 Chapter 10: Dynamic Invocation 43 Introduction 43 Syntax 43 Remarks 43 Examples 43 Field Accesses 43 Method Calls 44 Interaction Between Field Access and Update Method 44 Chapter 11: Enumerations 46 Remarks 46 Examples 46 Days of the week using Scala Enumeration 46 Using sealed trait and case objects 47 Using sealed trait and case objects and allValues-macro 48 Chapter 12: Error Handling 50 Examples 50 Try 50 Either 50 Option 51 Pattern Matching 51 Using map and getOrElse 51 Using fold 51 Converting to Java 51 Handling Errors Originating in Futures 52 Using try-catch clauses 52 Convert Exceptions into Either or Option Types 53 Chapter 13: Extractors 54 Syntax 54 Examples 54 Tuple Extractors 54 Case Class Extractors 55 Unapply - Custom Extractors 55 Extractor Infix notation 56 Regex Extractors 57 Transformative extractors 57 Chapter 14: For Expressions 59 Syntax 59 Parameters 59 Examples 59 Basic For Loop 59 Basic For Comprehension 59 Nested For Loop 60 Monadic for comprehensions 60 Iterate Through Collections Using a For Loop 61 Desugaring For Comprehensions 61 Chapter 15: Functions 63 Remarks 63 Difference between functions and methods: 63 Examples 63 Anonymous Functions 63 Underscores shorthand 64 Anonymous Functions with No Parameters 64 Composition 64 Relationship to PartialFunctions 65 Chapter 16: Futures 66 Examples 66 Creating a Future 66 Consuming a Successful Future 66 Consuming a Failed Future 66 Putting the Future Together 67 Sequencing and traversing Futures 67 Combine Multiple Futures – For Comprehension 68 Chapter 17: Handling units (measures) 70 Syntax 70 Remarks 70 Examples 70 Type aliases 70 Value classes 70 Chapter 18: Higher Order Function 72 Remarks 72 Examples 72 Using methods as function values 72 High Order Functions(Function as Parameter) 73 Arguments lazy evaluation 73 Chapter 19: If Expressions 75 Examples 75 Basic If Expressions 75 Chapter 20: Implicits 76 Syntax 76 Remarks 76 Examples 76 Implicit Conversion 76 Implicit Parameters 77 Implicit Classes 78 Resolving Implicit Parameters Using 'implicitly' 79 Implicits in the REPL 79 Chapter 21: Java Interoperability 80 Examples 80 Converting Scala Collections to Java Collections and vice versa 80 Arrays 80 Scala and Java type conversions 81 Functional Interfaces for Scala functions - scala-java8-compat 81 Chapter 22: JSON 83 Examples 83 JSON with spray-json 83 Make the Library Available with SBT 83 Import the Library 83 Read JSON 83 Write JSON 83 DSL 83 Read-Write to Case Classes 84 Custom Format 84 JSON with Circe 85 JSON with play-json 85 JSON with json4s 88 Chapter 23: Macros 91 Introduction 91 Syntax 91 Remarks 91 Examples 91 Macro Annotation 91 Method Macros 92 Errors in Macros 93 Chapter 24: Monads 95 Examples 95 Monad Definition 95 Chapter 25: Operator Overloading 97 Examples 97 Defining Custom Infix Operators 97 Defining Custom Unary Operators 97 Chapter 26: Operators in Scala 99 Examples 99 Built-in Operators 99 Operator Overloading 99 Operator Precedence 100 Chapter 27: Option Class 102 Syntax 102 Examples 102 Options as Collections 102 Using Option Instead of Null 102 Basics 103 Example with Map 104 Options in for comprehensions 104 Chapter 28: Packages 106 Introduction 106 Examples 106 Package structure 106 Packages and files 106 Package naming convension 107 Chapter 29: Parallel Collections 108 Remarks 108 Examples 108 Creating and Using Parallel Collections 108 Pitfalls 108 Chapter 30: Parser Combinators 110 Remarks 110 Examples 110 Basic Example 110 Chapter 31: Partial Functions 111 Examples 111 Composition 111 Usage with `collect` 111 Basic syntax 112 Usage as a total function 112 Usage to extract tuples in a map function 113 Chapter 32: Pattern Matching 115 Syntax 115 Parameters 115 Examples 115 Simple Pattern Match 115 Pattern Matching With Stable Identifier 116 Pattern Matching on a Seq 117 Guards (if expressions) 118 Pattern Matching with Case Classes 118 Matching on an Option 119 Pattern Matching Sealed Traits 119 Pattern Matching with Regex 120 Pattern binder (@) 120 Pattern Matching Types 121 Pattern Matching compiled as tableswitch or lookupswitch 121 Matching Multiple Patterns At Once 122 Pattern Matching on tuples 123 Chapter 33: Quasiquotes 125 Examples 125 Create a syntax tree with quasiquotes 125 Chapter 34: Recursion 126 Examples 126 Tail Recursion 126 Regular Recursion 126 Tail Recursion 126 Stackless recursion with trampoline(scala.util.control.TailCalls) 127 Chapter 35: Reflection 129 Examples 129 Loading a class using reflection 129 Chapter 36: Regular Expressions 130 Syntax 130 Examples 130 Declaring regular expressions 130 Repeating matching of a pattern in a string 131 Chapter 37: Scala.js 132 Introduction 132 Examples 132 console.log in Scala.js 132 Fat arrow functions 132 Simple Class 132 Collections 132 Manipulating DOM 132 Using with SBT 133 Sbt dependency 133 Running 133 Running with continous compilation: 133 Compile to a single JavaScript file: 133 Chapter 38: Scaladoc 134 Syntax 134 Parameters 134 Examples 135 Simple Scaladoc to method 135 Chapter 39: scalaz 136 Introduction 136 Examples 136 ApplyUsage 136 FunctorUsage 136 ArrowUsage 137 Chapter 40: Scope 138 Introduction 138 Syntax 138 Examples 138 Public (default) scope 138 A private scope 138 A private package-specific scope 139 Object private scope 139 Protected scope 139 Package protected scope 139 Chapter 41: Self types 141 Syntax 141 Remarks 141 Examples 141 Simple self type example 141 Chapter 42: Setting up Scala 142 Examples 142 On Linux via dpkg 142 Ubuntu Installation via Manual Download and Configuration 142 Mac OSX via Macports 143 Chapter 43: Single Abstract Method Types (SAM Types) 144 Remarks 144 Examples 144 Lambda Syntax 144 Chapter 44: Streams 145 Remarks 145 Examples 145 Using a Stream to Generate a Random Sequence 145 Infinite Streams via Recursion 145 Infinite self-referent stream 146 Chapter 45: String Interpolation 147 Remarks 147 Examples 147 Hello String Interpolation 147 Formatted String Interpolation Using the f Interpolator 147 Using expression in string literals 147 Custom string interpolators 148 String interpolators as extractors 149 Raw String Interpolation 149 Chapter 46: Symbol Literals 151 Remarks 151 Examples 151 Replacing strings in case clauses 151 Chapter 47: synchronized 153 Syntax 153 Examples 153 synchronize on an object 153 synchronize implicitly on this 153 Chapter 48: Testing with ScalaCheck 154 Introduction 154 Examples 154 Scalacheck with scalatest and error messages 154 Chapter 49: Testing with ScalaTest 157 Examples 157 Hello World Spec Test 157 Spec Test Cheatsheet 157 Include the ScalaTest Library with SBT 158 Chapter 50: Traits 159 Syntax 159 Examples 159 Stackable Modification with Traits 159 Trait Basics 160 Solving the Diamond Problem 160 Linearization 161 Chapter 51: Tuples 164 Remarks 164 Examples 164 Creating a new Tuple 164 Tuples within Collections 164 Chapter 52: Type Classes 166 Remarks 166 Examples 166 Simple Type Class 166 Extending a Type Class 167 Add type class functions to types 168 Chapter 53: Type Inference 170 Examples 170 Local Type Inference 170 Type Inference And Generics 170 Limitations to Inference 170 Preventing inferring Nothing 171 Chapter 54: Type Parameterization (Generics) 173 Examples 173 The Option type 173 Parameterized Methods 173 Generic collection 173 Defining the list of Ints 174 Defining generic list 174 Chapter 55: Type Variance 175 Examples
Recommended publications
  • Reversible Programming with Negative and Fractional Types

    Reversible Programming with Negative and Fractional Types

    9 A Computational Interpretation of Compact Closed Categories: Reversible Programming with Negative and Fractional Types CHAO-HONG CHEN, Indiana University, USA AMR SABRY, Indiana University, USA Compact closed categories include objects representing higher-order functions and are well-established as models of linear logic, concurrency, and quantum computing. We show that it is possible to construct such compact closed categories for conventional sum and product types by defining a dual to sum types, a negative type, and a dual to product types, a fractional type. Inspired by the categorical semantics, we define a sound operational semantics for negative and fractional types in which a negative type represents a computational effect that “reverses execution flow” and a fractional type represents a computational effect that“garbage collects” particular values or throws exceptions. Specifically, we extend a first-order reversible language of type isomorphisms with negative and fractional types, specify an operational semantics for each extension, and prove that each extension forms a compact closed category. We furthermore show that both operational semantics can be merged using the standard combination of backtracking and exceptions resulting in a smooth interoperability of negative and fractional types. We illustrate the expressiveness of this combination by writing a reversible SAT solver that uses back- tracking search along freshly allocated and de-allocated locations. The operational semantics, most of its meta-theoretic properties, and all examples are formalized in a supplementary Agda package. CCS Concepts: • Theory of computation → Type theory; Abstract machines; Operational semantics. Additional Key Words and Phrases: Abstract Machines, Duality of Computation, Higher-Order Reversible Programming, Termination Proofs, Type Isomorphisms ACM Reference Format: Chao-Hong Chen and Amr Sabry.
  • Let's Get Functional

    Let's Get Functional

    5 LET’S GET FUNCTIONAL I’ve mentioned several times that F# is a functional language, but as you’ve learned from previous chapters you can build rich applications in F# without using any functional techniques. Does that mean that F# isn’t really a functional language? No. F# is a general-purpose, multi paradigm language that allows you to program in the style most suited to your task. It is considered a functional-first lan- guage, meaning that its constructs encourage a functional style. In other words, when developing in F# you should favor functional approaches whenever possible and switch to other styles as appropriate. In this chapter, we’ll see what functional programming really is and how functions in F# differ from those in other languages. Once we’ve estab- lished that foundation, we’ll explore several data types commonly used with functional programming and take a brief side trip into lazy evaluation. The Book of F# © 2014 by Dave Fancher What Is Functional Programming? Functional programming takes a fundamentally different approach toward developing software than object-oriented programming. While object-oriented programming is primarily concerned with managing an ever-changing system state, functional programming emphasizes immutability and the application of deterministic functions. This difference drastically changes the way you build software, because in object-oriented programming you’re mostly concerned with defining classes (or structs), whereas in functional programming your focus is on defining functions with particular emphasis on their input and output. F# is an impure functional language where data is immutable by default, though you can still define mutable data or cause other side effects in your functions.
  • Dependency Injection with Unity

    Dependency Injection with Unity

    D EPEN DEPENDENCY INJECTION WITH UNITY Over the years software systems have evolutionarily become more and more patterns & practices D ENCY complex. One of the techniques for dealing with this inherent complexity Proven practices for predictable results of software systems is dependency injection – a design pattern that I allows the removal of hard-coded dependencies and makes it possible to Save time and reduce risk on your NJECT assemble a service by changing dependencies easily, whether at run-time software development projects by or compile-time. It promotes code reuse and loosely-coupled design which incorporating patterns & practices, I leads to more easily maintainable and flexible code. Microsoft’s applied engineering ON guidance that includes both production The guide you are holding in your hands is a primer on using dependency quality source code and documentation. W I injection with Unity – a lightweight extensible dependency injection TH DEPENDENCY INJECTION container built by the Microsoft patterns & practices team. It covers The guidance is designed to help U software development teams: various styles of dependency injection and also additional capabilities N I of Unity container, such as object lifetime management, interception, Make critical design and technology TY and registration by convention. It also discusses the advanced topics of selection decisions by highlighting WITH UNITY enhancing Unity with your custom extensions. the appropriate solution architectures, technologies, and Microsoft products The guide contains plenty of trade-off discussions and tips and tricks for for common scenarios managing your application cross-cutting concerns and making the most out of both dependency injection and Unity. These are accompanied by a Understand the most important Dominic Betts real world example that will help you master the techniques.
  • Notes on Functional Programming with Haskell

    Notes on Functional Programming with Haskell

    Notes on Functional Programming with Haskell H. Conrad Cunningham [email protected] Multiparadigm Software Architecture Group Department of Computer and Information Science University of Mississippi 201 Weir Hall University, Mississippi 38677 USA Fall Semester 2014 Copyright c 1994, 1995, 1997, 2003, 2007, 2010, 2014 by H. Conrad Cunningham Permission to copy and use this document for educational or research purposes of a non-commercial nature is hereby granted provided that this copyright notice is retained on all copies. All other rights are reserved by the author. H. Conrad Cunningham, D.Sc. Professor and Chair Department of Computer and Information Science University of Mississippi 201 Weir Hall University, Mississippi 38677 USA [email protected] PREFACE TO 1995 EDITION I wrote this set of lecture notes for use in the course Functional Programming (CSCI 555) that I teach in the Department of Computer and Information Science at the Uni- versity of Mississippi. The course is open to advanced undergraduates and beginning graduate students. The first version of these notes were written as a part of my preparation for the fall semester 1993 offering of the course. This version reflects some restructuring and revision done for the fall 1994 offering of the course|or after completion of the class. For these classes, I used the following resources: Textbook { Richard Bird and Philip Wadler. Introduction to Functional Program- ming, Prentice Hall International, 1988 [2]. These notes more or less cover the material from chapters 1 through 6 plus selected material from chapters 7 through 9. Software { Gofer interpreter version 2.30 (2.28 in 1993) written by Mark P.
  • Designpatternsphp Documentation Release 1.0

    Designpatternsphp Documentation Release 1.0

    DesignPatternsPHP Documentation Release 1.0 Dominik Liebler and contributors Jul 18, 2021 Contents 1 Patterns 3 1.1 Creational................................................3 1.1.1 Abstract Factory........................................3 1.1.2 Builder.............................................8 1.1.3 Factory Method......................................... 13 1.1.4 Pool............................................... 18 1.1.5 Prototype............................................ 21 1.1.6 Simple Factory......................................... 24 1.1.7 Singleton............................................ 26 1.1.8 Static Factory.......................................... 28 1.2 Structural................................................. 30 1.2.1 Adapter / Wrapper....................................... 31 1.2.2 Bridge.............................................. 35 1.2.3 Composite............................................ 39 1.2.4 Data Mapper.......................................... 42 1.2.5 Decorator............................................ 46 1.2.6 Dependency Injection...................................... 50 1.2.7 Facade.............................................. 53 1.2.8 Fluent Interface......................................... 56 1.2.9 Flyweight............................................ 59 1.2.10 Proxy.............................................. 62 1.2.11 Registry............................................. 66 1.3 Behavioral................................................ 69 1.3.1 Chain Of Responsibilities...................................
  • Design Patterns in Ocaml

    Design Patterns in Ocaml

    Design Patterns in OCaml Antonio Vicente [email protected] Earl Wagner [email protected] Abstract The GOF Design Patterns book is an important piece of any professional programmer's library. These patterns are generally considered to be an indication of good design and development practices. By giving an implementation of these patterns in OCaml we expected to better understand the importance of OCaml's advanced language features and provide other developers with an implementation of these familiar concepts in order to reduce the effort required to learn this language. As in the case of Smalltalk and Scheme+GLOS, OCaml's higher order features allows for simple elegant implementation of some of the patterns while others were much harder due to the OCaml's restrictive type system. 1 Contents 1 Background and Motivation 3 2 Results and Evaluation 3 3 Lessons Learned and Conclusions 4 4 Creational Patterns 5 4.1 Abstract Factory . 5 4.2 Builder . 6 4.3 Factory Method . 6 4.4 Prototype . 7 4.5 Singleton . 8 5 Structural Patterns 8 5.1 Adapter . 8 5.2 Bridge . 8 5.3 Composite . 8 5.4 Decorator . 9 5.5 Facade . 10 5.6 Flyweight . 10 5.7 Proxy . 10 6 Behavior Patterns 11 6.1 Chain of Responsibility . 11 6.2 Command . 12 6.3 Interpreter . 13 6.4 Iterator . 13 6.5 Mediator . 13 6.6 Memento . 13 6.7 Observer . 13 6.8 State . 14 6.9 Strategy . 15 6.10 Template Method . 15 6.11 Visitor . 15 7 References 18 2 1 Background and Motivation Throughout this course we have seen many examples of methodologies and tools that can be used to reduce the burden of working in a software project.
  • Scala by Example (2009)

    Scala by Example (2009)

    Scala By Example DRAFT January 13, 2009 Martin Odersky PROGRAMMING METHODS LABORATORY EPFL SWITZERLAND Contents 1 Introduction1 2 A First Example3 3 Programming with Actors and Messages7 4 Expressions and Simple Functions 11 4.1 Expressions And Simple Functions...................... 11 4.2 Parameters.................................... 12 4.3 Conditional Expressions............................ 15 4.4 Example: Square Roots by Newton’s Method................ 15 4.5 Nested Functions................................ 16 4.6 Tail Recursion.................................. 18 5 First-Class Functions 21 5.1 Anonymous Functions............................. 22 5.2 Currying..................................... 23 5.3 Example: Finding Fixed Points of Functions................ 25 5.4 Summary..................................... 28 5.5 Language Elements Seen So Far....................... 28 6 Classes and Objects 31 7 Case Classes and Pattern Matching 43 7.1 Case Classes and Case Objects........................ 46 7.2 Pattern Matching................................ 47 8 Generic Types and Methods 51 8.1 Type Parameter Bounds............................ 53 8.2 Variance Annotations.............................. 56 iv CONTENTS 8.3 Lower Bounds.................................. 58 8.4 Least Types.................................... 58 8.5 Tuples....................................... 60 8.6 Functions.................................... 61 9 Lists 63 9.1 Using Lists.................................... 63 9.2 Definition of class List I: First Order Methods..............
  • Simple Injector Documentation Release 5

    Simple Injector Documentation Release 5

    Simple Injector Documentation Release 5 Simple Injector Contributors Jul 27, 2021 Contents 1 Quick Start 3 1.1 Overview.................................................3 1.2 Getting started..............................................3 1.3 A Quick Example............................................4 1.3.1 Dependency Injection......................................4 1.3.2 Introducing Simple Injector...................................5 1.4 More information.............................................6 2 Using Simple Injector 7 2.1 Resolving instances...........................................9 2.2 Configuring Simple Injector....................................... 10 2.2.1 Auto-Registration/Batch-registration.............................. 13 2.3 Collections................................................ 14 2.3.1 Collection types......................................... 16 2.3.2 Auto-registering collections.................................. 16 2.3.3 Adding registrations to an existing collection......................... 17 2.4 Verifying the container’s configuration................................. 17 2.5 Automatic constructor injection / auto-wiring.............................. 18 2.6 More information............................................. 19 3 Object Lifetime Management 21 3.1 Transient Lifestyle............................................ 22 3.2 Singleton Lifestyle............................................ 22 3.3 Scoped Lifestyle............................................. 23 3.3.1 Disposing a Scope......................................
  • 61A Lecture 6 Lambda Expressions VS Currying

    61A Lecture 6 Lambda Expressions VS Currying

    Announcements • Homework 2 due Tuesday 9/17 @ 11:59pm • Project 2 due Thursday 9/19 @ 11:59pm • Optional Guerrilla section next Monday for students to master higher-order functions . Organized by Andrew Huang and the readers 61A Lecture 6 . Work in a group on a problem until everyone in the group understands the solution • Midterm 1 on Monday 9/23 from 7pm to 9pm Friday, September 13 . Details and review materials will be posted early next week . There will be a web form for students who cannot attend due to a conflict 2 Lambda Expressions >>> ten = 10 An expression: this one evaluates to a number >>> square = x * x Also an expression: evaluates to a function Lambda Expressions >>> square = lambda x: x * x Important: No "return" keyword! A function with formal parameter x that returns the value of "x * x" >>> square(4) 16 Must be a single expression Lambda expressions are not common in Python, but important in general (Demo) Lambda expressions in Python cannot contain statements at all! 4 Lambda Expressions Versus Def Statements def square(x): square = lambda x: x * x VS return x * x • Both create a function with the same domain, range, and behavior. • Both functions have as their parent the environment in which they were defined. Currying • Both bind that function to the name square. • Only the def statement gives the function an intrinsic name. The Greek letter lambda Example: http://goo.gl/XH54uE 5 Function Currying def make_adder(n): return lambda k: n + k >>> make_adder(2)(3) There's a general 5 relationship between (Demo) >>> add(2, 3) these functions 5 Newton's Method Currying: Transforming a multi-argument function into a single-argument, higher-order function.
  • CSE 341 : Programming Languages

    CSE 341 : Programming Languages

    CSE 341 : Programming Languages Lecture 10 Closure Idioms Zach Tatlock Spring 2014 More idioms • We know the rule for lexical scope and function closures – Now what is it good for A partial but wide-ranging list: • Pass functions with private data to iterators: Done • Combine functions (e.g., composition) • Currying (multi-arg functions and partial application) • Callbacks (e.g., in reactive programming) • Implementing an ADT with a record of functions (optional) 2 Combine functions Canonical example is function composition: fun compose (f,g) = fn x => f (g x) • Creates a closure that “remembers” what f and g are bound to • Type ('b -> 'c) * ('a -> 'b) -> ('a -> 'c) but the REPL prints something equivalent • ML standard library provides this as infix operator o • Example (third version best): fun sqrt_of_abs i = Math.sqrt(Real.fromInt(abs i)) fun sqrt_of_abs i = (Math.sqrt o Real.fromInt o abs) i val sqrt_of_abs = Math.sqrt o Real.fromInt o abs 3 Left-to-right or right-to-left val sqrt_of_abs = Math.sqrt o Real.fromInt o abs As in math, function composition is “right to left” – “take absolute value, convert to real, and take square root” – “square root of the conversion to real of absolute value” “Pipelines” of functions are common in functional programming and many programmers prefer left-to-right – Can define our own infix operator – This one is very popular (and predefined) in F# infix |> fun x |> f = f x fun sqrt_of_abs i = i |> abs |> Real.fromInt |> Math.sqrt 4 Another example • “Backup function” fun backup1 (f,g) = fn x => case
  • 1. Difference Between Factory Pattern and Abstract Factory Pattern S.No

    1. Difference Between Factory Pattern and Abstract Factory Pattern S.No

    1. Difference between Factory Pattern and Abstract Factory Pattern S.No Factory Pattern Abstract Factory Pattern 1 Create object through inheritance Create object through composition 2 Produce only one product Produce families of products 3 Implements code in the abstract creator Concrete factories implements factory that make use of the concrete type that method to create product sub class produces 2.Difference between Abstract Factory Pattern And Builder Pattern S.No Builder Pattern Abstract Factory Pattern 1 In Builder Pattern, there will be one Abstract Factory Pattern will return the Director class which will instruct Builder instance directly. class to build the different parts/properties of our object and finally retrieve the object. 2 It will have reference to the created It does not keep the track of it's created object. object. 3.Difference between Builder Pattern And Composite Pattern S.No Builder Pattern Composite Pattern 1 It is used to create group of objects of It creates Parent - Child relations between predefined types. our objects. 4.Difference between MVC and MVP S.No MVP MVC 1 MVP is a bit more complex to MVC is easier to implement than MVP. implement than MVC .Also, it has additional layer for view interfaces. 2 The request is always received by the The request is received by the controller View and delegated to the presenter which in turn gets the required data and which in turn gets the data does the loads up the appropriate view processing 3 The presentation and view logic an be The controller logic can be unit tested.
  • CS 3101-2 - Programming Languages: Scala Lecture 3: Fun with Functions

    CS 3101-2 - Programming Languages: Scala Lecture 3: Fun with Functions

    CS 3101-2 - Programming Languages: Scala Lecture 3: Fun with Functions Daniel Bauer ([email protected]) October 29, 2014 Daniel Bauer CS3101-2 Scala - 03 - Fun with Functions 1/37 Contents 1 Defining and Calling Functions 2 Higher Order Functions 3 Function Literals 4 Closures 5 Partially Applied Functions and Currying 6 By-Name Parameters Daniel Bauer CS3101-2 Scala - 03 - Fun with Functions 2/37 1 Defining and Calling Functions 2 Higher Order Functions 3 Function Literals 4 Closures 5 Partially Applied Functions and Currying 6 By-Name Parameters Daniel Bauer CS3101-2 Scala - 03 - Fun with Functions 3/37 Functions and Methods Functions that are members of some object (class instance or singleton) are called methods. private keyword makes method visible only within this object. import scala.io.Source object LongLines { def processFile(filename: String, width: Int) { val source = Source.fromFile(filename) for (l <- source.getLines) procLine(filename, width, l) } private def procLine(filename: String, l: String) { if (l.length > 79) println(filename +": "+ l.trim) } } Daniel Bauer CS3101-2 Scala - 03 - Fun with Functions 4/37 Local Functions Functions can be defined within other functions. Functions are only visible in surrounding scope. Inner function can access namespace of surrounding function. import scala.io.Source object LongLines { def processFile(filename: String, width: Int) { def procLine(l: String) { if (l.length > 79) println(filename +": "+ l.trim) } val source = Source.fromFile(filename) for (l <- source.getLines) procLine(filename, width, l) } } Daniel Bauer CS3101-2 Scala - 03 - Fun with Functions 5/37 Repeated Parameters The last parameter of a function may be repeated.