Functional programming
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 codi...
| Otros Autores: | |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Hoboken, New Jersey :
For Dummies
2019.
|
| Edición: | 1st edition |
| Colección: | For dummies
|
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630393506719 |
Tabla de Contenidos:
- Intro
- Title Page
- Copyright Page
- Table of Contents
- Introduction
- About This Book
- Foolish Assumptions
- Icons Used in This Book
- Beyond the Book
- Where to Go from Here
- Part 1 Getting Started with Functional Programming
- Chapter 1 Introducing Functional Programming
- Defining Functional Programming
- Understanding its goals
- Using the pure approach
- Using the impure approach
- Considering Other Programming Paradigms
- Imperative
- Procedural
- Object-oriented
- Declarative
- Using Functional Programming to Perform Tasks
- Discovering Languages That Support Functional Programming
- Considering the pure languages
- Considering the impure languages
- Finding Functional Programming Online
- Chapter 2 Getting and Using Python
- Working with Python in This Book
- Creating better code
- Debugging functionality
- Defining why notebooks are useful
- Obtaining Your Copy of Anaconda
- Obtaining Analytics Anaconda
- Installing Anaconda on Linux
- Installing Anaconda on MacOS
- Installing Anaconda on Windows
- Understanding the Anaconda package
- Downloading the Datasets and Example Code
- Using Jupyter Notebook
- Defining the code repository
- Getting and using datasets
- Creating a Python Application
- Understanding cells
- Adding documentation cells
- Other cell content
- Running the Python Application
- Understanding the Use of Indentation
- Adding Comments
- Understanding comments
- Using comments to leave yourself reminders
- Using comments to keep code from executing
- Closing Jupyter Notebook
- Getting Help with the Python Language
- Chapter 3 Getting and Using Haskell
- Working with Haskell in This Book
- Obtaining and Installing Haskell
- Installing Haskell on a Linux system
- Installing Haskell on a Mac system
- Installing Haskell on a Windows system.
- Testing the Haskell Installation
- Compiling a Haskell Application
- Using Haskell Libraries
- Getting Help with the Haskell Language
- Part 2 Starting Functional Programming Tasks
- Chapter 4 Defining the Functional Difference
- Comparing Declarations to Procedures
- Understanding How Data Works
- Working with immutable data
- Considering the role of state
- Eliminating side effects
- Seeing a Function in Haskell
- Using non-curried functions
- Using curried functions
- Seeing a Function in Python
- Creating and using a Python function
- Passing by reference versus by value
- Chapter 5 Understanding the Role of Lambda Calculus
- Considering the Origins of Lambda Calculus
- Understanding the Rules
- Working with variables
- Using application
- Using abstraction
- Performing Reduction Operations
- Considering α-conversion
- Considering β-reduction
- Considering η-conversion
- Creating Lambda Functions in Haskell
- Creating Lambda Functions in Python
- Chapter 6 Working with Lists and Strings
- Defining List Uses
- Creating Lists
- Using Haskell to create Lists
- Using Python to create lists
- Evaluating Lists
- Using Haskell to evaluate Lists
- Using Python to evaluate lists
- Performing Common List Manipulations
- Understanding the list manipulation functions
- Using Haskell to manipulate lists
- Using Python to manipulate lists
- Understanding the Dictionary and Set Alternatives
- Using dictionaries
- Using sets
- Considering the Use of Strings
- Understanding the uses for strings
- Performing string-related tasks in Haskell
- Performing string-related tasks in Python
- Part 3 Making Functional Programming Practical
- Chapter 7 Performing Pattern Matching
- Looking for Patterns in Data
- Understanding Regular Expressions
- Defining special characters using escapes
- Defining wildcard characters.
- Working with anchors
- Delineating subexpressions using grouping constructs
- Using Pattern Matching in Analysis
- Working with Pattern Matching in Haskell
- Performing simple Posix matches
- Matching a telephone number with Haskell
- Working with Pattern Matching in Python
- Performing simple Python matches
- Doing more than matching
- Matching a telephone number with Python
- Chapter 8 Using Recursive Functions
- Performing Tasks More than Once
- Defining the need for repetition
- Using recursion instead of looping
- Understanding Recursion
- Considering basic recursion
- Performing tasks using lists
- Upgrading to set and dictionary
- Considering the use of collections
- Using Recursion on Lists
- Working with Haskell
- Working with Python
- Passing Functions Instead of Variables
- Understanding when you need a function
- Passing functions in Haskell
- Passing functions in Python
- Defining Common Recursion Errors
- Forgetting an ending
- Passing data incorrectly
- Defining a correct base instruction
- Chapter 9 Advancing with Higher-Order Functions
- Considering Types of Data Manipulation
- Performing Slicing and Dicing
- Keeping datasets controlled
- Focusing on specific data
- Slicing and dicing with Haskell
- Slicing and dicing with Python
- Mapping Your Data
- Understanding the purpose of mapping
- Performing mapping tasks with Haskell
- Performing mapping tasks with Python
- Filtering Data
- Understanding the purpose of filtering
- Using Haskell to filter data
- Using Python to filter data
- Organizing Data
- Considering the types of organization
- Sorting data with Haskell
- Sorting data with Python
- Chapter 10 Dealing with Types
- Developing Basic Types
- Understanding the functional perception of type
- Considering the type signature
- Creating types
- Composing Types.
- Understanding monoids
- Considering the use of Nothing, Maybe, and Just
- Understanding semigroups
- Parameterizing Types
- Dealing with Missing Data
- Handling nulls
- Performing data replacement
- Considering statistical measures
- Creating and Using Type Classes
- Part 4 Interacting in Various Ways
- Chapter 11 Performing Basic I/O
- Understanding the Essentials of I/O
- Understanding I/O side effects
- Using monads for I/O
- Interacting with the user
- Working with devices
- Manipulating I/O Data
- Using the Jupyter Notebook Magic Functions
- Receiving and Sending I/O with Haskell
- Using monad sequencing
- Employing monad functions
- Chapter 12 Handling the Command Line
- Getting Input from the Command Line
- Automating the command line
- Considering the use of prompts
- Using the command line effectively
- Accessing the Command Line in Haskell
- Using the Haskell environment directly
- Making sense of the variety of packages
- Obtaining CmdArgs
- Getting a simple command line in Haskell
- Accessing the Command Line in Python
- Using the Python environment directly
- Interacting with Argparse
- Chapter 13 Dealing with Files
- Understanding How Local Files are Stored
- Ensuring Access to Files
- Interacting with Files
- Creating new files
- Opening existing files
- Manipulating File Content
- Considering CRUD
- Reading data
- Updating data
- Completing File-related Tasks
- Chapter 14 Working with Binary Data
- Comparing Binary to Textual Data
- Using Binary Data in Data Analysis
- Understanding the Binary Data Format
- Working with Binary Data
- Interacting with Binary Data in Haskell
- Writing binary data using Haskell
- Reading binary data using Haskell
- Interacting with Binary Data in Python
- Writing binary data using Python
- Reading binary data using Python.
- Chapter 15 Dealing with Common Datasets
- Understanding the Need for Standard Datasets
- Finding the Right Dataset
- Locating general dataset information
- Using library-specific datasets
- Loading a Dataset
- Working with toy datasets
- Creating custom data
- Fetching common datasets
- Manipulating Dataset Entries
- Determining the dataset content
- Creating a DataFrame
- Accessing specific records
- Part 5 Performing Simple Error Trapping
- Chapter 16 Handling Errors in Haskell
- Defining a Bug in Haskell
- Considering recursion
- Understanding laziness
- Using unsafe functions
- Considering implementation-specific issues
- Understanding the Haskell-Related Errors
- Fixing Haskell Errors Quickly
- Relying on standard debugging
- Understanding errors versus exceptions
- Chapter 17 Handling Errors in Python
- Defining a Bug in Python
- Considering the sources of errors
- Considering version differences
- Understanding the Python-Related Errors
- Dealing with late binding closures
- Using a variable
- Working with third-party libraries
- Fixing Python Errors Quickly
- Understanding the built-in exceptions
- Obtaining a list of exception arguments
- Considering functional style exception handling
- Part 6 The Part of Tens
- Chapter 18 Ten Must-Have Haskell Libraries
- binary
- Hascore
- vect
- vector
- aeson
- attoparsec
- bytestring
- stringsearch
- text
- moo
- Chapter 19 Ten (Plus) Must-Have Python Packages
- Gensim
- PyAudio
- PyQtGraph
- TkInter
- PrettyTable
- SQLAlchemy
- Toolz
- Cloudera Oryx
- funcy
- SciPy
- XGBoost
- Chapter 20 Ten Occupation Areas that Use Functional Programming
- Starting with Traditional Development
- Going with New Development
- Creating Your Own Development
- Finding a Forward-Thinking Business
- Doing Something Really Interesting.
- Developing Deep Learning Applications.
