Functional Programming in Golang: Apply functional techniques in Go to improve the testability, readability, and security of your code

Functional Programming in Go
Contributors
About the author
About the reviewer
Preface
    Who this book is for
    What this book covers
    To get the most out of this book
    Download the example code files
    Download the color images
    Conventions used
    Get in touch
    Share your thoughts
    Download a free PDF copy of this book
Part 1: Functional Programming Paradigm Essentials
Chapter 1: Introducing Functional Programming
    What is functional programming?
        Introducing first-class functions
        What are pure functions?
        Say what you want, not how you want it
    A brief history of functional programming
    Modern functional programming
    The Go programming paradigm
    Why functional programming?
    Why not functional programming in Go?
    Comparing FP and OOP
    Summary
Chapter 2: Treating Functions as First-Class Citizens
    Technical requirements
    Benefits of first-class functions
    Defining types for functions
        Type aliases for primitives
        Type aliases for functions
    Using functions as objects
        Passing functions to functions
        In-line function definitions
        Anonymous functions
        Returning functions from functions
        Functions in var
        Functions inside data structures
        Functions inside structs
    Example 1 – map dispatcher
        Creating a simple calculator
    Example 2 – mocking functions for testing
    Summary
Chapter 3: Higher-Order Functions
    Technical requirements
    An introduction to higher-order functions
    Closures and variable scoping
        Variable scoping in Go
        Capturing variable context in functions (closures)
    Partial application
    Function currying, or how to reduce n-ary functions to unary functions
        Example: function currying
    Example: server constructor
    Summary
Chapter 4: Writing Testable Code with Pure Functions
    Technical requirements
    What is purity?
        Demonstrating pure versus impure function calls
        Referential transparency
        Idempotence
        Statelessness
        Side effects
    Why does purity improve our code?
        Increases the testability of our code
        Increases the confidence in our code
        Improved confidence in function names and signatures
        Safer concurrency
    When not to write pure functions
        Input/output operations
        Non-determinism can be desired
        When we really have to panic!
    How do we create pure functions?
        Avoid global state
        Separate pure and impure functionality
    Example 1 – hotdog shop
        Bad hotdog shop
        Better hotdog shop
    Summary
Chapter 5: Immutability
    Technical requirements
    What is immutability?
        Immutability at the data layer
    How to write immutable code in Go
        Writing immutable code for collection data types
    Measuring performance in mutable and immutable code
        Benchmarking functions
        Understanding stacks, heaps, and garbage collection
    When to write mutable functions
    What are functors and monads?
        What’s a functor?
        From functor to monad
    Summary
Part 2: Using Functional Programming Techniques
Chapter 6: Three Common Categories of Functions
    Technical requirements
    Predicate-based functions
        Implementing a Filter function
        Any or all
        Implementing DropWhile and TakeWhile
    Map/transformation functions
        Transformations while maintaining the data type
    Data reducing functions
    Example – working with airport data
    Summary
Chapter 7: Recursion
    Technical requirements
    What is recursion?
    Why do functional languages favor recursion?
    When to use recursive functions
        Iterating over trees
    Recursion and functions as first-class citizens
    Limits of recursive functions
        Measuring the performance of recursive versus iterative solutions
        Space limitation of recursive functions
        Tail recursion as a solution to stack limitations
    Summary
Chapter 8: Readable Function Composition with Fluent Programming
    Technical requirements
    Chaining functions through dot notation
        Chaining methods for object creation (builder pattern)
        Dot notation to chain functions on slices
        Infinite data structures and lazy evaluation
        Continuation-passing style programming
        CPS and goroutines
        When to use CPS?
    Summary
Part 3: Design Patterns and Functional Programming Libraries
Chapter 9: Functional Design Patterns
    Technical requirements
    Classical design patterns in a functional paradigm
        The strategy pattern
        The decorator pattern
        The Hollywood principle
    Functional design patterns
    Summary
Chapter 10: Concurrency and Functional Programming
    Technical requirements
    Functional programming and concurrency
        Concurrency, parallelism, and distributed computing
        Functional programming and concurrency
    Creating concurrent functions
        Concurrent filter implementation
        Concurrent Map and FMap implementation
    The pipeline pattern
    Summary
Chapter 11: Functional Programming Libraries
    Technical requirements
        Is the library alive – and do the examples still match it?
        Legal requirements
    Pre-generics libraries for creating common FP functions
        Code generation libraries for pre-generics Go
    Post-generics functional programming libraries
        Pie with generics
        Lodash, for Go
        Mo, for go
    Summary
Index
    Why subscribe?
Other Books You May Enjoy
    Packt is searching for authors like you
    Share your thoughts
    Download a free PDF copy of this book