SINGAPORE
Law
Welcome Guest | Login
SEARCH
Advanced
Professional Functional Programming in C# : Classic Programming Techniques for Modern Projects: Sturm, Oliver: BOOKS KINOKUNIYA
Book Details
Professional Functional Programming in C# : Classic Programming Techniques for Modern Projects
Professional Functional Programming in C# : Classic Programming Techniques for Modern Projects
Publisher : John Wiley & Sons Inc
Published Date : 2011/04
Binding : Paperback
ISBN : 9780470744581

BookWeb Price : S$ 50.24
Kinokuniya Privilege Card member price : S$ 45.22

Availability Status : In stock at the Fulfillment Centre.
Usually dispatches within 5 working days.
Language : English
Stock Information
Store Shelf Location Click here Stock
Singapore Main Store H10-04, H10-01 Map
Liang Court Store -
Bugis Junction Store -
Important
  • While every attempt has been made to ensure stock availability, occasionally we do run out of stock at our stores.
  • Retail store and online prices may vary.
  • To confirm availability and pricing, please call the store directly.
Retail Store Contact Details and Operating Hours

Book Description
Source: ENG
Academic Descriptors: A93603277
Place of Publication: United States
Textual Format: Computer Applications
Academic Level: Extracurricular
Review:
Baker & Taylor Newly Released Computer Titles - January 2002 - Ongoing
Baker & Taylor Best-seller And Forthcoming Computer Titles - January 2000 - Ongoing
Table of Contents
 
Introduction                                       xiii
Part I Introduction To Functional Programming
  Chapter 1 A Look At Functional Programming       3   (6)
  History
    What Is Functional Programming?                3   (2)
    Functional Languages                           5   (2)
    The Relationship to Object Oriented            7   (1)
    Programming
    Summary                                        8   (1)
  Chapter 2 Putting Functional Programming Into    9   (8)
  A Modern Context
    Managing Side Effects                          10  (1)
    Agile Programming Methodologies                11  (1)
    Declarative Programming                        11  (1)
    Functional Programming Is a Mindset            12  (1)
    Is Functional Programming in C# a Good Idea?   13  (1)
    Summary                                        13  (4)
Part II C# Foundations Of Functional Programming
  Chapter 3 Functions, Delegates, And Lambda       17  (14)
  Expressions
    Functions and Methods                          17  (2)
    Reusing Functions                              19  (4)
    Anonymous Functions and Lambda Expressions     23  (3)
    Extension Methods                              26  (2)
    Referential Transparency                       28  (2)
    Summary                                        30  (1)
  Chapter 4 Flexible Typing With Generics          31  (12)
    Generic Functions                              32  (2)
    Generic Classes                                34  (1)
    Constraining Types                             35  (2)
    Other Generic Types                            37  (1)
    Covariance and Contravariance                  38  (3)
    Summary                                        41  (2)
  Chapter 5 Lazy Listing With Iterators            43  (12)
    The Meaning of Laziness                        43  (1)
    Enumerating Things with .NET                   44  (3)
    Implementing Iterator Functions                47  (4)
      Returning IEnumerator                        50  (1)
    Chaining Iterators                             51  (2)
    Summary                                        53  (2)
  Chapter 6 Encapsulating Data In Closures         55  (6)
    Constructing Functions Dynamically             55  (1)
    The Problem with Scope                         56  (1)
    How Closures Work                              57  (3)
    Summary                                        60  (1)
  Chapter 7 Code Is Data                           61  (16)
    Expression Trees in .NET                       63  (1)
    Analyzing Expressions                          64  (4)
    Generating Expressions                         68  (4)
    .NET 4.0 Specifics                             72  (2)
    Summary                                        74  (3)
Part III Implementing Well-Known Functional
Techniques in C#
  Chapter 8 Currying And Partial Application       77  (14)
    Decoupling Parameters                          77  (9)
      Manual Currying                              78  (2)
      Automatic Currying                           80  (2)
      Calling Curried Functions                    82  (1)
      The Class Context                            82  (3)
      What FCSlib Contains                         85  (1)
    Calling Parts of Functions                     86  (2)
    Why Parameter Order Matters                    88  (1)
    Summary                                        89  (2)
  Chapter 9 Lazy Evaluation                        91  (10)
    What's Good about Being Lazy?                  92  (1)
    Passing Functions                              93  (2)
    Explicit Lazy Evaluation                       95  (3)
    Comparing the Lazy Evaluation Techniques       98  (1)
      Usability                                    98  (1)
      Efficiency                                   98  (1)
    How Lazy Can You Be?                           99  (1)
    Summary                                        100 (1)
  Chapter 10 Caching Techniques                    101 (16)
    The Need to Remember                           101 (1)
    Precomputation                                 102 (5)
    Memoization                                    107 (8)
      Deep Memoization                             110 (4)
      Considerations on Memoization                114 (1)
    Summary                                        115 (2)
  Chapter 11 Calling Yourself                      117 (14)
    Recursion in C#                                117 (2)
    Tail Recursion                                 119 (2)
    Accumulator Passing Style                      121 (1)
    Continuation Passing Style                     122 (4)
    Indirect Recursion                             126 (3)
    Summary                                        129 (2)
  Chapter 12 Standard Higher Order Functions       131 (10)
    Applying Operations: Map                       132 (6)
      Using Criteria: Filter                       132 (1)
      Accumulating: Fold                           133 (5)
    Map, Filter, and Fold in LINQ                  138 (2)
    Standard Higher Order Functions                140 (1)
    Summary                                        140 (1)
  Chapter 13 Sequences                             141 (8)
    Understanding List Comprehensions              141 (1)
    A Functional Approach to Iterators             142 (1)
    Ranges                                         143 (3)
    Restrictions                                   146 (1)
    Summary                                        147 (2)
  Chapter 14 Constructing Functions From           149 (10)
  Functions
    Composing Functions                            149 (3)
    Advanced Partial Application                   152 (3)
    Combining Approaches                           155 (3)
    Summary                                        158 (1)
  Chapter 15 Optional Values                       159 (8)
    The Meaning of Nothing                         159 (1)
    Implementing Option(al) Values                 160 (5)
    Summary                                        165 (2)
  Chapter 16 Keeping Data From Changing            167 (26)
    Change Is Good湧ot!                            167 (1)
    False Assumptions                              168 (9)
      Being Static Is Good                         169 (1)
      A Matter of Depth                            170 (1)
      Cloning                                      171 (2)
      Automatic Cloning                            173 (4)
    Implementing Immutable Container Data          177 (13)
    Structures
      Linked List                                  177 (6)
      Queue                                        183 (2)
      Unbalanced Binary Tree                       185 (2)
      Red/Black Tree                               187 (3)
    Alternatives to Persistent Data Types          190 (1)
    Summary                                        191 (2)
  Chapter 17 Monads                                193 (16)
    What's in a Typeclass?                         194 (3)
    What's in a Monad?                             197 (1)
    Why Do a Whole Abstraction?                    198 (3)
    A Second Monad: Logging                        201 (2)
    Syntactic Sugar                                203 (1)
    Binding with SelectMany?                       204 (1)
    Summary                                        205 (4)
Part IV Putting Functional Programming Into
Action
  Chapter 18 Integrating Functional Programming    209 (24)
  Approaches
    Refactoring                                    210 (14)
      List Filtering with a Windows Forms UI       211 (5)
      Calculating Mandelbrot Fractals              216 (8)
    Writing New Code                               224 (5)
      Use Static Methods                           224 (2)
      Prefer Anonymous Methods Over Named Ones     226 (1)
      Prefer Higher Order Functions over Manual    227 (1)
      Algorithm Implementation
      Prefer Immutable Data                        228 (1)
      Watch Behavior Implementation in Classes     229 (1)
    Finding Likely Candidates for Functional       229 (3)
    Programming
      Shades of Grey                               230 (1)
      Using What's There                           231 (1)
    Summary                                        232 (1)
  Chapter 19 The MapReduce Pattern                 233 (8)
    Implementing MapReduce                         234 (3)
    Abstracting the Problem                        237 (3)
    Summary                                        240 (1)
  Chapter 20 Applied Functional Modularization     241 (6)
    Executing SQL Code from an Application         241 (2)
    Rewriting the Function with Partial            243 (2)
    Application and Precomputation in Mind
    Summary                                        245 (2)
  Chapter 21 Existing Projects Using Functional    247 (14)
  Techniques
    The .NET Framework                             247 (2)
    LINQ                                           249 (8)
      LINQ to Objects                              249 (4)
      LINQ to a Query Backend                      253 (2)
      Parallelization                              255 (2)
    Google MapReduce and Its Implementations       257 (1)
    NUnit                                          258 (2)
    Summary                                        260 (1)
Index                                              261
 

Take advantage of the growing trend in functional programming. C# is the number-one language used by .NET developers and one of the most popular programming languages in the world. It has many built-in functional programming features, but most are complex and little understood. With the shift to functional programming increasing at a rapid pace, you need to know how to leverage your existing skills to take advantage of this trend. Functional Programming in C# leads you along a path that begins with the historic value of functional ideas. Inside, C# MVP and functional programming expert Oliver Sturm explains the details of relevant language features in C# and describes theory and practice of using functional techniques in C#, including currying, partial application, composition, memoization, and monads. Next, he provides practical and versatile examples, which combine approaches to solve problems in several different areas, including complex scenarios like concurrency and high-performance calculation frameworks as well as simpler use cases like Web Services and business logic implementation.Shows how C# developers can leverage their existing skills to take advantage of functional programming Uses very little math theory and instead focuses on providing solutions to real development problems with functional programming methods, unlike traditional functional programming titles Includes examples ranging from simple cases to more complex scenarios Let Functional Programming in C# show you how to get in front of the shift toward functional programming.

Contents
INTRODUCTION. PART I1: A LOOK AT FUNCTIONAL PROGRAMMING HISTORY. CHAPTER 2: PUTTING FUNCTIONAL PROGRAMMING INTO A MODERN CONTEXT. PART II: C# FOUNDATIONS OF FUNCTIONAL PROGRAMMING. CHAPTER 3: FUNCTIONS, DELEGATES, AND LAMBDA EXPRESSIONS. CHAPTER 4: FLEXIBLE TYPING WITH GENERICS. CHAPTER 5: LAZY LISTING WITH ITERATORS. CHAPTER 6: ENCAPSULATING DATA IN CLOSURES. CHAPTER 7: CODE IS DATA. PART III: IMPLEMENTING WELL-KNOWN FUNCTIONAL TECHNIQUES IN C#. CHAPTER 8: CURRYING AND PARTIAL APPLICATION. CHAPTER 9: LAZY EVALUATION. CHAPTER 10: CACHING TECHNIQUES. CHAPTER 11: CALLING YOURSELF. CHAPTER 12: STANDARD HIGHER ORDER FUNCTIONS. CHAPTER 13: SEQUENCES. CHAPTER 14: CONSTRUCTING FUNCTIONS FROM FUNCTIONS. CHAPTER 15: OPTIONAL VALUES. CHAPTER 16: KEEPING DATA FROM CHANGING. CHAPTER 17: MONADS. PART IV: PUTTING FUNCTIONAL PROGRAMMING INTO ACTION. CHAPTER 18: INTEGRATING FUNCTIONAL PROGRAMMING APPROACHES. CHAPTER 19: THE MAPREDUCE PATTERN. CHAPTER 20: APPLIED FUNCTIONAL MODULARIZATION. CHAPTER 21: EXISTING PROJECTS USING FUNCTIONAL TECHNIQUES. INDEX.