Cover image for Functional Programming For Dummies

Functional Programming For Dummies

Author John Paul Mueller
Release Date: 2019/02/01
Topic:
0%
34
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

Book Description

Your guide to the functional programming paradigm 

Functional programming mainly sees use in math computations, including those used in Artificial Intelligence and gaming. This programming paradigm makes algorithms used for math calculations easier to understand and provides a concise method of coding algorithms by people who aren't developers. Current books on the market have a significant learning curve because they're written for developers, by developers—until now. 

Functional Programming for Dummies explores the differences between the pure (as represented by the Haskell language) and impure (as represented by the Python language) approaches to functional programming for readers just like you. The pure approach is best suited to researchers who have no desire to create production code but do need to test algorithms fully and demonstrate their usefulness to peers. The impure approach is best suited to production environments because it's possible to mix coding paradigms in a single application to produce a result more quickly. Functional Programming For Dummies uses this two-pronged approach to give you an all-in-one approach to a coding methodology that can otherwise be hard to grasp.

  • Learn pure and impure when it comes to coding
  • Dive into the processes that most functional programmers use to derive, analyze and prove the worth of algorithms
  • Benefit from examples that are provided in both Python and Haskell
  • Glean the expertise of an expert author who has written some of the market-leading programming books to date

If you’re ready to massage data to understand how things work in new ways, you’ve come to the right place!

Table of Contents

  1. Cover
  2. Introduction
    1. About This Book
    2. Foolish Assumptions
    3. Icons Used in This Book
    4. Beyond the Book
    5. Where to Go from Here
  3. Part 1: Getting Started with Functional Programming
    1. Chapter 1: Introducing Functional Programming
      1. Defining Functional Programming
      2. Considering Other Programming Paradigms
      3. Using Functional Programming to Perform Tasks
      4. Discovering Languages That Support Functional Programming
      5. Finding Functional Programming Online
    2. Chapter 2: Getting and Using Python
      1. Working with Python in This Book
      2. Obtaining Your Copy of Anaconda
      3. Downloading the Datasets and Example Code
      4. Creating a Python Application
      5. Running the Python Application
      6. Understanding the Use of Indentation
      7. Adding Comments
      8. Closing Jupyter Notebook
      9. Getting Help with the Python Language
    3. Chapter 3: Getting and Using Haskell
      1. Working with Haskell in This Book
      2. Obtaining and Installing Haskell
      3. Testing the Haskell Installation
      4. Compiling a Haskell Application
      5. Using Haskell Libraries
      6. Getting Help with the Haskell Language
  4. Part 2: Starting Functional Programming Tasks
    1. Chapter 4: Defining the Functional Difference
      1. Comparing Declarations to Procedures
      2. Understanding How Data Works
      3. Seeing a Function in Haskell
      4. Seeing a Function in Python
    2. Chapter 5: Understanding the Role of Lambda Calculus
      1. Considering the Origins of Lambda Calculus
      2. Understanding the Rules
      3. Performing Reduction Operations
      4. Creating Lambda Functions in Haskell
      5. Creating Lambda Functions in Python
    3. Chapter 6: Working with Lists and Strings
      1. Defining List Uses
      2. Creating Lists
      3. Evaluating Lists
      4. Performing Common List Manipulations
      5. Understanding the Dictionary and Set Alternatives
      6. Considering the Use of Strings
  5. Part 3: Making Functional Programming Practical
    1. Chapter 7: Performing Pattern Matching
      1. Looking for Patterns in Data
      2. Understanding Regular Expressions
      3. Using Pattern Matching in Analysis
      4. Working with Pattern Matching in Haskell
      5. Working with Pattern Matching in Python
    2. Chapter 8: Using Recursive Functions
      1. Performing Tasks More than Once
      2. Understanding Recursion
      3. Using Recursion on Lists
      4. Passing Functions Instead of Variables
      5. Defining Common Recursion Errors
    3. Chapter 9: Advancing with Higher-Order Functions
      1. Considering Types of Data Manipulation
      2. Performing Slicing and Dicing
      3. Mapping Your Data
      4. Filtering Data
      5. Organizing Data
    4. Chapter 10: Dealing with Types
      1. Developing Basic Types
      2. Composing Types
      3. Parameterizing Types
      4. Dealing with Missing Data
      5. Creating and Using Type Classes
  6. Part 4: Interacting in Various Ways
    1. Chapter 11: Performing Basic I/O
      1. Understanding the Essentials of I/O
      2. Manipulating I/O Data
      3. Using the Jupyter Notebook Magic Functions
      4. Receiving and Sending I/O with Haskell
    2. Chapter 12: Handling the Command Line
      1. Getting Input from the Command Line
      2. Accessing the Command Line in Haskell
      3. Accessing the Command Line in Python
    3. Chapter 13: Dealing with Files
      1. Understanding How Local Files are Stored
      2. Ensuring Access to Files
      3. Interacting with Files
      4. Manipulating File Content
      5. Completing File-related Tasks
    4. Chapter 14: Working with Binary Data
      1. Comparing Binary to Textual Data
      2. Using Binary Data in Data Analysis
      3. Understanding the Binary Data Format
      4. Working with Binary Data
      5. Interacting with Binary Data in Haskell
      6. Interacting with Binary Data in Python
    5. Chapter 15: Dealing with Common Datasets
      1. Understanding the Need for Standard Datasets
      2. Finding the Right Dataset
      3. Loading a Dataset
      4. Manipulating Dataset Entries
  7. Part 5: Performing Simple Error Trapping
    1. Chapter 16: Handling Errors in Haskell
      1. Defining a Bug in Haskell
      2. Understanding the Haskell-Related Errors
      3. Fixing Haskell Errors Quickly
    2. Chapter 17: Handling Errors in Python
      1. Defining a Bug in Python
      2. Understanding the Python-Related Errors
      3. Fixing Python Errors Quickly
  8. Part 6: The Part of Tens
    1. Chapter 18: Ten Must-Have Haskell Libraries
      1. binary
      2. Hascore
      3. vect
      4. vector
      5. aeson
      6. attoparsec
      7. bytestring
      8. stringsearch
      9. text
      10. moo
    2. Chapter 19: Ten (Plus) Must-Have Python Packages
      1. Gensim
      2. PyAudio
      3. PyQtGraph
      4. TkInter
      5. PrettyTable
      6. SQLAlchemy
      7. Toolz
      8. Cloudera Oryx
      9. funcy
      10. SciPy
      11. XGBoost
    3. Chapter 20: Ten Occupation Areas that Use Functional Programming
      1. Starting with Traditional Development
      2. Going with New Development
      3. Creating Your Own Development
      4. Finding a Forward-Thinking Business
      5. Doing Something Really Interesting
      6. Developing Deep Learning Applications
      7. Writing Low-Level Code
      8. Helping Others in the Health Care Arena
      9. Working as a Data Scientist
      10. Researching the Next Big Thing
  9. Index
  10. About the Author
  11. Connect with Dummies
  12. End User License Agreement
18.224.63.87