Symbols

• - (dash), use in switches, 198
• -- (double dash), use in switches, 198
• % (percent sign), 192
• %% (double percent sign), 192
• %%timeit magic function, 194
• %alias magic function, 193
• %autocall magic function, 193
• %automagic magic function, 193
• %autosave magic function, 193
• %cd magic function, 193
• %cls magic function, 193
• %colors magic function, 193
• %config magic function, 193
• %dhist magic function, 193
• %file magic function, 194
• %hist magic function, 194
• %install_ext magic function, 194
• %load magic function, 194
• %load_ext magic function, 194
• %lsmagic magic function, 194
• %magic magic function, 194
• %matplotlib magic function, 194, 238
• %paste magic function, 194
• %pdef magic function, 194
• %pdoc magic function, 194
• %pinfo magic function, 194
• %pinfo2 magic function, 194
• %reload_ext magic function, 194
• %source magic function, 194
• %timeit magic function, 194

• (>>) monad sequencing operator, 195

• . (dot) operator, 152, 158–159

• / (slash), use in switches, 198

• :set command, 201
• :t expression, 162, 167
• :t openFile function, 190
• :unse t command, 200

• x0A output, 228
• x0D output, 228

• __getattribute() function, 267

• ` (back quotation mark), use in Haskell, 98

• | (OR) operator, 166–167

• ++ operator, 189

• <<loop>> output, 256
• <> operator, 173

• == (equality) operator, 179

A

• α (alpha)-conversion, 85

• abstracting
  • patterns, 112
  • simply-typed calculus, 83–84
  • untyped lambda calculus, 82–83
• aeson library, 274
• AI (Artificial Intelligence), 277
• algorithms
  • human element in, 251
  • pattern matching, 118
  • types of, 280
• alpha (α)-conversion, 85
• Amazon Web Services. See AWS
• Amazon.com, 292
• American Mathematical Society (AMS), 273
• Anaconda
  • add-ons for, 22
  • applications within, 26–27
  • downloading, 21–22
  • installing
    • on Linux, 22–23
    • on Mac OS, 23–24
    • on Windows, 24–26
  • version 5.1, 19
• anchors, 115–116
• AND operator, creating types with, 164–166
• Apache Hadoop, 285
• Apache Kafka, 285
• Apache Spark, 285
• append function, 75, 102
• appendFile function, 191
• appending data, 75, 102, 129–130, 173, 212
• AppendMode argument, 212
• applications
  • Anaconda, 26–27
  • Haskell, 56–59
  • in lambda calculus, 81–82
  • patterns in, 112
  • Python, 34–38
  • repetition in, 126–127
  • state of, 13, 74–76
• apply operators
  • interacting with user, 189
  • lambda calculus, 81–82
  • mapping tasks, 152
• Argparse library, 205, 206
• args property, 266
• arguments
  • command line
    • Haskell, 200–201
    • Python, 205–206
  • exception, 266–267
  • replacing bound variables with, 86–87
• argv variable name, 205
• ArithmeticError exception, 265
• arrays
  • difference between lists and, 93
  • NumPy, 221, 236
• Artificial Intelligence (AI), 277
• ASCII, 220, 275
• assert function, 258
• attoparsec library, 275
• automating
  • command line, 198–199
  • data patterns, 113
• AWS (Amazon Web Services)
  • AWS Lambda, 290
  • certifications, 290–291
  • JSON and, 274
• Azure, Microsoft, 290

B

• β (beta)-reduction, 86–88

• back quotation mark (`), use in Haskell, 98
• base case, 131
• base classes, Python, 265
• Beale's function, 277
• Bernoulli trial, 221
• beta (β)-reduction, 86–88
• bi-clustering, 238

• The Big Think article, 251

• binary data
  • defined, 219
  • format of, 222–224
  • Haskell, interacting with using, 228–229
  • overview, 219
  • textual data, comparing to, 220–221
  • using in data analysis, 221–222
• binary library, 271–272
• bit manipulation, 224
• Boolean values, 221–222
• bound variables, 86
• BREAD (Browse, Read, Edit, Add, and Delete) acronym, 213
• bugs, 20, 250–253, 255, 260
• Builder module, 276
• businesses, using functional programming methodologies, 292
• bytearray type, 228
• bytes, defined, 221
• bytestring calls, 275
• bytestring library, 275–276

C

• C math library, 252
• C# programming language, 12
• C++ programming language
  • object-oriented, 14
  • overview, 12
  • synonyms in code, 170
  • type signatures, using, 162
• c=Y argument, 239
• Cabal utility, 59–60, 202–203, 209
• calculus. See also lambda calculus
  • simply-typed, 83–84
  • untyped, 82–83
• calls, bytestring, 275
• carriage return (0D), 223
• CD (Change Directory) command, 38
• cells, 35–38
• centers argument, 238
• cereal library, 272
• Change Directory (CD) command, 38
• characters
  • character encoding, 191
  • defined, 105
  • special, 114–115
  • wildcard, 115
• Church, Alonzo, 78–81, 83–84
• classifying time frames, 260–261
• Clojure language, 285, 295
• closures, late binding, 263–264
• Cloud, Google, 291
• cloud device, 190
• Cloudera Oryx package, 285
• clustering data. See also grouping data
  • bi-clustering, 238
  • defined, 158
• CmdArgs, 201–203
• cmp100 function, 138–139
• code. See also functional programming paradigm
  • comments preventing execution of, 43–44
  • errors in, 20
  • importing, 59
  • low-level, 293–294
  • monolithic, 187
  • recursion in, 129, 130
  • repository for, 28–33
  • side effects in, 65
  • spaghetti, 14
  • synonyms in, 170
  • transitioning of, 82
• Colab (Google Colaboratory), 27, 291
• collections
  • as method for recursive functions, 134
  • as monoids, 173–174
• command line
  • automating, 198–200
  • error detection, creating, 197
  • Haskell, accessing, 200–205
  • overview, 197
  • Python, accessing, 205–206
  • syntax, 197
• Command Line Option Parsers page, 201–202
• comments in Python, 41–44
• common datasets, 239–241
• comparing function, 159
• Compcert C Compiler, 293
• compile time errors, Python, 259–260
• compilers, 13, 161, 293
• concatenation, 39, 101, 172
• concrete exceptions, Python, 265
• concurrent programming, 293
• constructors
  • data, 167–170
  • type, 167–170
• Continuum Analytics website, 22, 23
• Control.Exception.catch function, 258
• Control.Exception.try function, 258
• Control.Monad library, 127
• Control.Monad.Error function, 258
• conversion. See reduction operations
• correct base instruction, recursion, 141–142
• count() function, 244
• create_values(5) function, 263
• CRUD (Create, Read, Update, and Delete), 144, 207, 212–214, 232
• curried functions, 72, 74–76
• Curry, Haskell, 78
• currying, 70–71, 79, 82
• custom data, 232, 238–239
• cvtToTuple function, 177, 204
• CyToolz package, 285

D

• dash (-), use in switches, 198
• data. See also datasets; lists
  • analyzing, importance of, 143
  • application state, modifying, 68–69
  • arrays, 93
  • binary
    • comparing to textual data, 220–221
    • format of, 222–224
    • interacting with in Haskell, 225–228
    • interacting with in Python, 225–228
    • overview, 219
    • reasons to use, 225
    • using in data analysis, 221–222
  • cleaning, 144
  • defined, 67
  • dicing, 146–151
  • filtering, 143
  • within functional programming paradigm, 67–69
  • immutable, 68
  • manipulating, 144–145, 191–192
  • mapping, 152–153
  • missing, 113, 178–181
  • organizing, 144, 157–160
  • passing incorrectly, 141
  • pattern matching, 112–113, 117
  • reading, 214–216
  • replacing, 180
  • searching for, 117
  • slicing, 146–151
  • transforming, 144–145
  • underlying, 221
  • updating, 216
  • verification of, 144–145
• data analysis
  • pattern matching, 117–118
  • using binary data in, 221–222
• data constructors, 167–170
• data keyword, 164
• data property, 241, 243
• data scientists, 295
• data types, 84, 166
• database. See also data
  • database managers, 144, 147
  • defined, 284
• DataBase Management System (DBMS), 284
• Data.Binary.Builder library, 226
• Data.Bits library, 224
• Data.ByteString.Builder library, 226
• Data.ByteString.Char8 library, 227
• DataFrame, creating, 243–244
• Data.IntMap function, 152
• Data.List library, 102
• Data.List.NonEmpty list, 176
• Data.Map.Lazy function, 152
• Data.Map.Strict function, 152
• Data.Set library, 132
• datasets
  • accessing specific records in, 244–245
  • choosing, 233–236
  • common, 239–241
  • controlling size of, 146–147
  • custom data, 238–239
  • Dataframe and, 243–244
  • determining content of, 241–243
  • dicing, 146–151
  • duplicate entries, deleting, 91
  • form issues, 145
  • in Haskell, 59–60
  • image, 235
  • LFW, 240
  • linnerud, multivariate regression using, 237
  • loading, 60, 236–241
  • nested dictionaries and, 133
  • numeric data, labeling within, 105
  • overview, 231–232
  • in Python, 33–34
  • randomizing, 147
  • sample code, 243
  • slicing, 146–151
  • standard, 232–233
  • SVM, 235
  • toy, 235, 237–238
• Data.String library, 106
• DBMS (DataBase Management System), 284
• debugging
  • defined, 20
  • IDEs and, 20, 49
  • passing functions, 138
  • standard, 256–257
• Debug.Trace.trace function, 258
• decision problem (Entscheidungsproblem), 79
• declarations
  • defined, 65
  • differences between declarations and, 66–67
• declarative programming, 14
• deep learning applications, 293
• def arguments, 204
• DESCR property, 241, 243
• deserialization, 227
• developers, functional programming paradigm and, 291
• devices, I/O, 189–191
• dicing data, 146–151
• dict structure, 91
• dictionaries, 103–104, 132–134
• dir() command, 244
• dir() function, 241, 267
• displayData function, 216
• doAdd function, 163
• documentation, for Haskell, 60
• domains, function, 83
• doRep function, 129
• dot (.) operator, 152, 158–159
• double dash (--), use in switches, 198
• double percent sign (%%), 192
• Double type, 254
• dual function, 173–174
• Duck Typing, 164

E

• eager (strict) bytestring call, 275
• eager (strict) evaluation, 16
• editing lists, 101
• Emacs text editor, 49
• entries, dataset, 241–245
• Entscheidungsproblem (decision problem), 79
• enumerations, 167–168
• equality (==) operator, 179
• Erlang programming language, 12
• error function, 258
• errors
  • exceptions versus, 258
  • in Haskell
    • bugs, 250–253
    • fixing, 256–258
    • overview, 249–250
    • sources of, 254–256
  • logical, 262
  • in Python
    • bugs, 260
    • fixing, 265–268
    • late binding closure, 263–264
    • overview, 259–260
    • sources of, 260–262
    • third-party libraries, potential problems with, 264
    • variables, using, 264
    • version difference, 263–264
  • semantic, 262
  • syntactical, 261–262
  • types of, 261–262
• escapes, character, 114–115
• eta (η)-conversion, 88
• evaluations, 97
  • non-strict, 16
  • strict, 16
• exceptions
  • built-in, 265
  • errors versus, 258
  • exception arguments, 266–267
• exporting notebook files, 31–32
• expressions
  • defined, 111
  • regular, 113–124
• external load dataset, 235

F

• Facebook, use of job sites, 292
• feature_names property, 241, 243
• fetch_20newsgroups(subset='train') dataset, 240
• fetch_lfw_people(min_faces_per_person=70, resize=0.4) dataset, 240
• fetch_mldata('MNIST original', data_home=custom_data_home) dataset, 240
• fetch_olivetti_faces() dataset, 239
• fields, RDBMS, 284
• file handles, 188, 190, 210, 217, 252
• file management
  • access issues, 209
  • closing files, 217
  • creating new files, 210
  • CRUD acronym, 213–214
  • general discussion, 212–213
  • locking files, 211
  • opening existing files, 211–212
  • overview, 207
  • reading data, 214–215
  • storing local files, 208
  • updating data, 215–216
• FileNotFoundError exception, 265
• filter function, 102
• findKey function, 134
• flags, defined, 221
• Float type, 254
• floating-point values, 220
• for loop, 134, 151
• forM function, 127, 149
• format, of binary data, 222–224
• Fractional type, 254, 268
• France vector, 281
• free (unbound) variables, 86–87
• frozenset object, 104
• fst function, 177
• function application, defined, 79
• functional abstraction, defined, 79
• Functional Jobs website, 290
• functional programming paradigm
  • basis for, 15–16
  • data within, 67–69
  • declarations, 66–67
  • languages supporting, 16–17
  • multiprocessor use and, 128
  • occupations using, 289–295
  • online resources for, 17–18
  • other paradigms and, 13–14
  • overview, 10–12
  • procedures, 66–67
• Functional Works website, 292
• functions. See also lambda calculus; recursive functions
  • abstraction and, 82
  • anonymous, 89
  • converting, 72
  • domain of, 83
  • first-class, 15
  • in Haskell, 69–72, 98
  • higher-order, 15
  • importing datasets into Python code with, 33–34
  • invoking, 83
  • lambda
    • defined, 85
    • multiplying list elements, 100
    • performing special sort, 160
    • in Python, 90, 136, 153, 156
    • recursion of, 131
    • shortcuts for, 89
    • simplifying, 86
  • magic, 192–194
  • for manipulating lists, 101
  • pure, 15, 17
  • in Python, 73–76
• functools.partial() function, 264
• funcy package, 285–286

G

• GA (Genetic Algorithm), 277
• GADT (General Algebraic Datatypes), 202
• Gaussian blobs, 33, 238
• GBM (Gradient Boosting Machine), 287
• General Algebraic Datatypes (GADT), 202
• General Data Protection Regulation (GDPR), 232
• generators, 235
• Genetic Algorithm (GA), 277
• Gensim library, 280–281
• getArgs function, 200
• getDual function, 174
• getLine function, 188, 195
• GHC (Glasgow Haskell Compiler), 253, 272
• GHCi (Glasgow Haskell Compiler interpreter), 54, 57, 190
• global data, 68–69
• Gödel, Kurt, 78
• Google, use of job sites, 292
• Google Cloud, 291
• Google Colaboratory (Colab), 27, 291
• Gradient Boosting Machine (GBM), 287
• Gradient Boosting Regression, 242
• Graphical User Interface (GUI), 283
• grave accent mark (`), use in Haskell, 98
• Greet data type, 204
• grouping data
  • defined, 158
  • grouping constructs, 116
  • groups, 171–172
• GUI (Graphical User Interface), 283

H

• η (eta)-conversion, 88

• Hacker News website, 18
• Hadoop, Apache, 285
• handles, 188, 190, 210, 217, 252
• Hascore library, 273
• HashMap, 103
• Haskell
  • accessing command line in, 200–205
  • application, compiling, 56–59
  • back question mark in, 98
  • building from source files, 50
  • data
    • dicing, 147–149
    • filtering, 155–156
    • immutable, 68
    • mapping, 152–153
    • organizing, 158–159
    • slicing, 147–149
  • errors in
    • bugs, 250–253
    • fixing, 256–258
    • general discussion, 253–256
    • overview, 249–250
    • sources of, 254–256
  • functions in, 69–72, 98
  • HackageDB, 61
  • installing
    • on Linux, 50
    • on MacOS, 50–51
    • overview, 48–49
    • on Windows, 52–54
  • interacting with binary data in, 225–228
  • interpreted information about, 55
  • lambda functions, creating in, 89
  • libraries, 59–60, 271–277
  • lists in, 94–95, 97–99, 101–102, 135–136
  • non-strict evaluation, 16
  • online resources for, 60–61
  • passing functions with, 138–139
  • pattern matching in, 118–120
  • quitting, 55
  • reading data, 215
  • receiving I/O with, 195–196
  • recursion in, 57
  • sending I/O with, 195–196
  • Software Repository, 61
  • string-related tasks in, 106
  • tuples in, 133
  • tutorials for, 61
  • use of grave accent mark in, 98
  • version 8.2.2, 48
• Hasse diagram, 222
• hClose function, 217
• headings
  • comments versus, 41
  • in documentation cells, 36
• health care industry, 294–295

• --help command-line switch, 205

• hexadecimal editors, 222
• hGetChar function, 215
• hGetContents function, 216, 227
• hGetLine function, 215
• hGetPosn function, 215
• HLearn library, 236
• hLookAhead function, 215
• host devices, 189
• hPutBuilder function, 226
• hPutStrLn function, 190
• htrace function, 257
• HyperHaskell, 49

I

• IDE (Integrated Development Environment). See also Jupyter Notebook
  • for Haskell, 49
  • intelligence of, 20
  • Spyder, 27
• image datasets, 235
• immutable data, 68
• imperative programming, 13
• implementation-specific issues, 253
• importing
  • datasets into Python code, 33–34
  • external code, 59
  • notebook files, 32–33
  • regular expressions library, 121
• impure languages, 12, 17, 222
• inc function, 70, 74
• Indeed.com, 290, 295
• indentation, in Python, 39–41
• inductive reasoning, lambda calculus, 80
• indValue(2) function, 263
• infinite loops, 250
• Infinity value, 259
• input devices, 190
• input method, 188
• Input/Output. See I/O
• instance keyword, 168
• int data type, 84
• Int values, 135, 165
• integers, 220
• Integrated Development Environment. See IDE
• interpreters, 293
• IntMap operator, 173
• IntSet operator, 173
• I/O (Input/Output)
  • devices, 189–191
  • interacting with user, 188–189
  • Jupyter Notebook magic functions, 192–194
  • manipulating, 191–192
  • overview, 185–186
  • sending and receiving with Haskell, 195–196
  • side effects, 186–188
  • using monads for, 188
• IOError function, 258
• IPython magic functions, 192–194
• Italy vector, 281
• iterations, list, 101

J

• JavaScript, 12
• JavaScript Object Notation (JSON), 274
• Jet.com, 292
• JFIF (JPEG File Information Format), 224
• JPEG (Joint Photographic Experts Group), 224
• JPEG File Information Format (JFIF), 224
• JSON (JavaScript Object Notation), 274
• Jupyter Notebook
  • advantages of, 21
  • booting up, 28
  • cells in, 35–36
  • closing, 44
  • coding in, 20
  • debugging capabilities of, 20
  • Haskell add-on for, 49
  • magic functions, 192–194
  • notebook files, 30–33
  • stopping server of, 28, 44
• Just value, 174–176

K

• Kafka, Apache, 285
• key keyword, 160
• KeyboardInterrupt exception, 265
• keywords, 90, 160, 164, 168
• Kleene, Stephen, 80
• Knuth, Donald, 21

L

• Labeled Faces in the Wild (LFW) dataset, 240
• lambda calculus
  • abstraction and, 82–84
  • apply operator, 81–82
  • functions in
    • data typing and, 137
    • defined, 85
    • Haskell-related, 89
    • list elements, multiplying, 100
    • performing special sort with, 160
    • Python-related, 89–90, 153, 156
    • recursion of, 131
    • simplifying, 86
    • updating file data with, 216
  • operations of, 80–84
  • origins of, 78–80
  • overview, 77
  • principles of, 79
  • reduction operations, 85–88
  • use of colon in, 84
  • variables in, 80–81
• LambdaCube engine, 273
• language optimizer, 186
• languages. See also names of specific languages; programming languages
  • impure, 12, 17, 222
  • lazy, 251–252
  • pure, 16–17
• late binding closures, 263–264
• lazy (non-strict) bytestring call, 275
• lazy (non-strict) evaluation, 16
• lazy (non-strict) language, 251–252
• Leksah IDE, 49
• length function, 98, 159
• Lex/Yacc language, 12
• LFW (Labeled Faces in the Wild) dataset, 240
• libraries
  • Argparse, 205
  • C math, 252
  • cereal, provisions of, 272
  • defined, 271
  • functools, 100
  • GHC version, 272
  • Haskell, 59–60, 271–276
  • HLearn, 236
  • hmatrix, 146
  • music oriented, 273
  • naming, 274
  • NumPy, 99, 146
  • pandas, 146
  • PyMonad, 176
  • Python, 280–283, 286
  • regular expressions, 121, 123
  • Scikitlearn, 33, 234
  • sound oriented, 273
  • statistics, 100
  • SymPy, 222
  • third-party, 192, 264
  • vector, 146
• library-specific datasets, 234–236
• libsvm dataset, 235
• line feed (0A), 223
• linnerud datasets, 237
• Linux
  • installing Anaconda on, 22–23
  • installing Haskell on, 50
  • Windows operating system versus, 208
• Lisp programming language, 12
• list comprehensions, 133
• list function, 156
• list object, 153
• lists
  • alternatives to, 103–104
  • creating, 93–96
  • differences between arrays and, 93
  • evaluating, 96–100
  • manipulating, 100–102
  • as method for recursive functions, 131–132
  • uses for, 92–93
  • using recursive functions on, 135–137
• literate programming, 21
• load_boston() function, 237
• load_breast_cancer() function, 237
• load_diabetes() function, 237
• load_digits([n_class]) function, 237
• load_iris() function, 237
• load_linnerud() function, 237
• load_wine() function, 237
• local files, storing, 208
• location pointer, defined, 214
• locking files, 211
• logical errors, 262
• lookup function, 133
• loops
  • defined, 250
  • infinite, 250
  • using recursive functions instead of, 127–128
• low-level code, writing
  • compilers, 293
  • concurrent programming, 293
  • interpreters, 293
  • parallel programming, 293

M

• machine code, 13
• MacOS
  • installing Anaconda on, 23–24
  • installing Haskell on, 50–51
• magic functions, Jupyter Notebook, 192–194
• main function, 216
• make_ blobs() function, 238
• manipulating data
  • I/O data, 144–145
  • lists, 100–102
  • types of data manipulation, 144–145
• map function, 72, 152
• map object, 153
• Map operator, 173
• marks, types of, 98
• math. See also lambda calculus
  • abstraction, 171
  • Peano arithmetic, 79
  • solving problems with, 10
• MATLAB, 10, 21
• Maybe value, 174–176
• measures, statistical, 180–181
• membership, list, 101
• MemoryError exception, 265
• Microsoft Azure, 290
• Miranda programming language, 16
• mod operator, 156
• modularization, 11
• modules, 55–56, 280
• monads
  • functions, 195–196
  • handles and, 188
  • monad sequencing, 195
• monoids, 170–174
• monolithic code, 187
• moo library, 277
• multivariate regression, 237
• music oriented libraries, 273
• mutable variables, avoiding, 250
• mypy static type checker, 163

N

• n_samples argument, 238

• --name argument, 204

• name=Sam argument, 205
• Native.py argument, 205
• natural language processing (NLP), 280
• Navigator, Anaconda, 26, 45–46
• neoVim text editor, 49
• NLP (natural language processing), 280
• non-curried functions, 72, 74–76
• non-strict (lazy) bytestring call, 275
• non-strict (lazy) evaluation, 16
• non-strict (lazy) language, 251–252
• notebooks. See also Jupyter Notebook
  • creating new, 30–31
  • deleting, 32
  • exporting, 31–32
  • importing, 32–33
  • text editors versus, 21
• Nothing value, 174–176
• null values, 178–179
• numeric values, 220
• NumPy
  • arrays, 221, 236
  • evaluating lists with, 99
  • slicing and dicing data with, 146
• numpy/routines.io library, 236

O

• Object-Oriented Programming (OOP), 14, 180
• OCaml programming language, 12
• occupations, using functional programming
  • businesses, finding, 292
  • data scientist, 295
  • deep learning applications, 293
  • developers, 289–291
  • health care industry, 294–295
  • low-level code writing, 293–294
  • overview, 289
  • researching, 295
  • sites for, 292–293
• OOP (Object-Oriented Programming), 14, 180
• openBinaryFile function, 226
• operations. See also lambda calculus
  • of lambda calculus, 80–84
  • reduction operations. See reduction operations
• operator module, 160
• OR (|) operator, 166–167
• OS exceptions, 265
• output. See also I/O
  • comments as, 42
  • inputs and, 17
  • Int values as, 135
  • in Jupyter Notebook, 30–31
  • lines of text, multiple, 39–40
  • output devices, 190
  • procedures and, 67

P

• packages
  • defined, 280
  • Haskell, 201–202
  • Python, 279–287
• pandas.io library, 235
• paradigms, 9. See also functional programming paradigm
• parallel programming, 293
• parameterizing, 176–178
• parentheses, in lambda calculus, 81
• Paris vector, 281
• partial file lock, 211
• passing by reference, Python variables, 74–76
• pattern matching
  • algorithm, 118
  • in analysis, 117–118
  • in data, patterns, 112–113
  • defined, 111
  • in Haskell, 118–120
  • in Python, 121–124
  • regular expressions, 113–124
• Peano arithmetic, 79
• percent sign (%) symbol, 192
• Posix matches, 118–119
• Post, Emil Leon, 78
• Prelude.catch function, 258
• PrettyTable library, 283
• prime (`) symbol, use in Haskell, 98
• print() call, 237
• print() function, 13–14, 30, 34, 210
• programming. See also functional programming paradigm
  • concurrent, 293
  • declarative, 14
  • functional, 9–18
  • imperative, 13
  • literate, 21
  • object-oriented, 14
  • parallel, 293
  • procedural, 13–14
• programming languages
  • C#, 12
  • C++, 12, 14, 162, 170
  • functional features in, 12
  • η-conversion and, 88
  • impure, 17
  • Lisp, 12
  • Miranda, 16
  • non functional, using type signatures, 162
  • OCaml, 12
  • pure, 16–17
  • Racket, 12
  • supporting coding styles, 17
  • supporting coding styles with, 17
• Prompt, Anaconda
  • code, running using, 38
  • description of, 27
  • Infix module, installing with, 90
  • lists, creating using, 95
• prompts, in applications, 198–199
• protocol, communication, 192
• pure functions, 186, 187
• pure languages, 11–12, 16–17
• putCharUtf8 function, 226
• putStringUtf8 function, 226
• putStrLn function, 188–189, 190, 195, 227
• PyAudio library, 281–282
• PyGame library, 282
• PyMonad library, 176
• PyQtGraph library, 282–283
• Python
  • accessing command line in, 205–206
  • Anaconda, 21–27
  • bit manipulation and, 224
  • calls, 215
  • code, 28–33, 38–39
  • comments in, 41–44
  • creating application, 34–38
  • data
    • dicing with, 150–151
    • filtering, 156
    • immutable, 68
    • mapping, 153–154
    • organizing, 159–160
  • data typing, 137
  • datasets in, 33–34
  • errors in, 259–268
  • exception arguments, 266–267
  • functions in, 73–76, 139–140
  • as impure language, 17
  • indentation in, 39–41
  • interacting with binary data in, 228–229
  • Jupyter Notebook, 20–21, 44
  • lambda functions, creating in, 89–90
  • lists in, 95–96, 99–100, 102, 136–137
  • matches for, 121–123
  • objects, mutability of, 76
  • online resources for, 45–46
  • packages, 279–287
  • parameterizing types in, 178
  • pattern matching in, 121–124
  • reading data, 215
  • slicing data, 150–151
  • sound technologies of, 282
  • string-related tasks in, 106–107
  • type signatures, 163
• Python Package Index, 279

Q

• Quora website, 18

R

• Racket programming language, 12
• range, lambda calculus, 83
• RCV1 (Reuters Corpus Volume I), 240
• RDBMS (Relational DataBase Management System), 284
• readFile function, 191, 216, 217
• reading binary data, 227–229
• readme, 277
• ReadWriteMode argument, 210
• records
  • accessing, 244–245
  • defined, 284
• recursions
  • defined, 15
  • in Haskell, 57
  • as method for recursive functions, 129–131
  • overview, 250–251
• recursive functions
  • errors in, 140–142
  • on lists, 135–137
  • loops versus, 127–128
  • methods for, 129–134
  • overview, 126–128
  • passing functions with, 137–140
• reduction operations. See also lambda calculus
  • alpha conversion, 85
  • beta reduction, 86–88
  • eta conversion, 88
• referential transparency, 15
• Regex code class, 114, 118
• regression, multivariate, 237
• regular expressions, 113–116
• Relational DataBase Management System (RDBMS), 284
• rem operator, 156
• removeFile function, 217
• repetition, list, 101
• replace function, 216
• replicate function, 196
• repository, code, 28
• ResourceWarning exception, 265
• Reuters Corpus Volume I (RCV1), 240
• reverse functions, 102
• reverse keyword, 160
• Rome vector, 281
• Rosser, J. B., 80
• runtime errors, Python, 260

S

• sayHello template, 204
• scaling, 187
• Scikitlearn library, 33, 234
• SciPy library, 286
• scipy.io library, 236
• scipy.io.wavfile.read library, 236
• semantic errors, 262
• semigroups, 172, 176
• Sequence operator, 173
• serialization, 226, 271–272
• server, Jupyter Notebook, 28, 44
• Set operator, 173
• set structure, 91
• sets, 104, 132–134
• side effects, I/O, 186–188
• simply-typed calculus, 83–84
• simply-typed variables, 81
• skimage.io library, 236
• sklearn.datasets, 34
• sklearn.datasets.fetch_covtype() dataset, 240
• sklearn.datasets.fetch_rcv1() dataset, 240
• slash (/), use in switches, 198
• slice function, 149
• slicing data, 146–151
• snd function, 159, 177
• Sookochef, Kevin, 18
• sortBy function, 159
• sorted function, 159
• sound oriented libraries, 273
• spaghetti code, 14
• Spark, Apache, 285
• special characters, 114–115
• split function, 123
• Spotify, use of job sites, 292
• Spyder, 27
• SQL (Structured Query Language), 10, 12, 117, 284
• SQLAlchemy package, 284
• StackOverflow website, 61
• standard datasets, 232–233
• static type checkers, 163
• statistical measures, 180–181
• stderr handle, 188
• stdin handle, 188
• stdout handle, 188, 190
• strict (eager) bytestring call, 275
• strict (eager) evaluation, 16
• String data type, 168, 216
• strings, 105–107
• stringsearch library, 276
• Structured Query Language (SQL), 10, 12, 117, 284
• sub function, 123–124
• Sum data type, 165
• sum functions, 98
• Support Vector Machine (SVM) datasets, 235
• svmlight dataset, 235
• SymPy library, 222
• syntactical errors, 261–262
• System.Directory function, 217
• System.Environment function, 200
• System.IO.Unsafe package, 252

T

• target property, 241, 243
• tasks, performing, 66–67
• Tcl (Tool Command Language), 283
• TechRepublic website, 295
• telephone numbers
  • matching, 120, 124
  • patterns in, 112
• testing
  • custom data, 232
  • defined, 187
  • Haskell installation, 54–56
  • stakeholder, 255
• Text data type, 216
• text editors
  • Emacs, 49
  • neoVim, 49
  • notebooks versus, 21
  • Vim text, 49
• text library, 276–277
• Text.Regex.Posix package, 118
• textual data, 220–221
• third-party libraries, 192, 264
• tinymce website, 18
• Tk (Toolkit), 283
• TkInter package, 283
• Tool Command Language (Tcl), 283
• Toolkit (Tk), 283
• Toolz package, 284–285
• toy datasets, 235, 237–238
• trace function, 257
• trace output, 257
• tuples
  • in Haskell, 133
  • overview, 160
  • as type, 119
• Turing, Alan Mathison, 78
• Tutorials Point website, 18
• Two Sigma, use of job sites, 292
• type classes, 181–182
• type constructors, 168–170
• type function, 162
• types
  • composing, 170–176
  • conversation between, 92–93
  • data constructors, 168–169
  • defined, 83, 161
  • enumerations, 167–168
  • functional perception of, 162
  • general discussion, 164–168
  • monoids, 170–176
  • AND operator and, 164–166
  • OR operator and, 166–167
  • parameterizing, 176–178
  • semigroups, 176
  • type constructors, 168–169
  • type signatures, 162–164

U

• UCI Machine Learning Repository, 233, 234
• unbound (free) variables, 86–87
• Unicode Transformation Format (UTF), 191, 276
• unpack function, 216
• unsafe functions, 252–253
• untyped lambda calculus, 82–83
• untyped variables, 80–81, 87–88
• username argument, 204
• UTF (Unicode Transformation Format), 191, 276

V

• values
  • Boolean, 221–222
  • enumerating, 167
  • floating-point, 220
  • index, 97
  • Int values, 135, 165
  • in lists, 94
  • null, 178–179
  • numeric, 220
  • types of, 220
• variables
  • assigning anonymous functions to, 89
  • bound, 86
  • changing content of, 68
  • data constructor versus, 167
  • functions, passing to, 69
  • in lambda calculus, 80
  • mapping, 82, 89
  • overview, 264
  • renaming, 85
  • replacing, 86
  • simply-typed, 81
  • unbound, 86
  • untyped, 80–81, 87–88
• vect library, 273
• vector library, 274

• --version command-line switch, 205

• Vim text editor, 49
• Von Neumann, John, 78

W

• while statement, 141
• wildcard characters, 115
• Wildly Inaccurate website, 18
• Windows
  • installing Anaconda on, 24–26
  • installing Haskell on, 52–54
  • Linux operating system versus, 207
• WinGHCi interpreter, 54, 203, 256
• winsound package, 282
• Word2vec algorithm, 281
• words, binary data, 221
• writeFile function, 191, 216, 217
• WriteMode argument, 210
• writing binary data, 226–227, 228–229

X

• XGBoost package, 287
• XVI32 hexadecimal editor, 222

Z

• ZeroDivisionError exception, 268
• zip functions, 102