Index
A
- absolute value, Guards
- accumulator, Counting Up, Folding Lists
- after clause, Catching Runtime Errors as They Happen
- analysis
- and operator, Atomic Booleans
- andalso operator, Atomic Booleans
- application(s)
- arguments, passing functions as, Simple Higher-Order Functions
- (see also higher-order functions)
- asynchronous communications, Creating Services with gen_server
- atoms, Atoms-Atomic Booleans
C
- calculator
- case construct, Evaluating Cases-Evaluating Cases, Variable Assignment in case and if Constructs
- characters, gathering from user, Gathering Characters
- clauses (see function clauses)
- Clojure, Are You Sure You Want Erlang?
- closure, Simple Higher-Order Functions
- clusters, pids and, The Shell Is a Process
- code
- communication
- community, Erlang, Community
- compilation, Defining Modules, Defining Modules
- composite/complex data types, Adding Structure: Tuples
- cons (list constructor), Splitting Lists into Heads and Tails
- CouchDB, Data Storage
- countdown, Counting Down
- counting up, Counting Up
D
- data storage, alternative approaches to, Data Storage
- data types, for documentation/analysis, Data Types for Documentation and Analysis
- data, structured (see structured data)
- database management system (DBMS) (see Mnesia)
- debugging
- declarations, record, Setting Up Records
- DETS, Next Steps
- Dialyzer, Testing, Analyzing, and Refactoring
- disk-based storage (see Mnesia)
- distributed computing, Distributed Computing
- documentation, Documenting Code-Documenting Your Application
- duplicate bags, Storing Records in Erlang Term Storage
E
- EDoc, Documenting Code-Documenting Your Application
- Elixir, Are You Sure You Want Erlang?, Languages Built on Erlang
- empty lists, Splitting Lists into Heads and Tails, Processing List Content
- Erlang (generally)
- calling functions, Calling Functions
- community, Community
- compilation and runtime system, Defining Modules
- etudes/exercises for, Etudes for Erlang
- installation, Installation
- languages built on, Languages Built on Erlang
- learning resources, Other Resources
- numbers in, Numbers in Erlang
- operators, Operators
- reserved words, Reserved Words
- shell, First Steps: The Shell-Moving through Files
- shell commands, Shell Commands
- starting, Firing It Up
- syntax, A Note on Erlang Syntax
- tools for connecting with other programming languages, Extending Erlang
- working with variables in shell, Working with Variables in the Shell-Clearing Bound Variables in the Shell
- Erlang runtime system (ERTS), Defining Modules
- Erlang Term Storage (ETS), Storing Records in Erlang Term Storage-Next Steps
- errors
- error_logger module, Logging Progress and Failure
- etudes, Erlang, Etudes for Erlang
- exceptions, raising with throw, Raising Exceptions with throw
- exercises, Erlang, Etudes for Erlang
- exit trapping, Breaking Things and Linking Processes
F
- F#, Are You Sure You Want Erlang?
- f() function, Clearing Bound Variables in the Shell
- factorials, calculating, Recursing with Return Values-Recursing with Return Values
- filtering list values, Filtering List Values
- flattening lists, List Basics
- floating-point numbers, Numbers in Erlang
- folding lists, Folding Lists-Folding Lists
- fun
- function calls, watching, Watching Function Calls
- function clauses, Pattern Matching with Atoms, Guards
- functions
- and case construct, Evaluating Cases-Evaluating Cases
- and variable scope, Functions and Variable Scope
- calling, Calling Functions
- creating with fun tool, Functions and Modules-Fun with fun
- defining in compiled modules, Defining Modules-Module Directives
- documenting, Documenting Functions-Documenting Functions
- higher-order (see higher-order functions)
- if construct, If This, Then That-If This, Then That
- io:format, The Gentlest Side Effect: io:format
- list of, Guard Components
- logic inside of, Logic and Recursion-Variable Assignment in case and if Constructs
- reserved words and, Reserved Words
- running list values through, Running List Values Through a Function
- simple recursion, Simple Recursion-Recursing with Return Values
- tracing, Watching Function Calls
- using records in, Using Records in Functions and Modules-Using Records in Functions and Modules
- watching calls, Watching Function Calls
I
- if construct, If This, Then That-If This, Then That
- improper list, Creating Lists with Heads and Tails
- infinite loop, Simple Recursion
- information, asking users for, Asking Users for Information-Reading Lines of Text
- installation, Installation
- integers, Numbers in Erlang
- io module, Input and Output
- io:format() function, The Gentlest Side Effect: io:format
L
- learning resources, Erlang, Other Resources
- Linux
- list comprehensions, Creating New Lists with Higher-Order Functions-Filtering List Values
- lists, Lists-Building a List of Lists
- advanced processing of, Beyond List Comprehensions-Folding Lists
- basics, List Basics-List Basics
- creating single list from multiple lists, List Basics
- creating with heads and tails, Creating Lists with Heads and Tails
- creating with higher-order functions, Creating New Lists with Higher-Order Functions-Filtering List Values
- folding, Folding Lists-Folding Lists
- mixing with tuples, Mixing Lists and Tuples
- of lists, List Basics, Building a List of Lists-Building a List of Lists
- processing content of, Processing List Content-Processing List Content
- splitting, Splitting Lists
- splitting into heads and tails, Splitting Lists into Heads and Tails
- testing, Testing Lists
- tuples vs., List Basics
- logic
- logic errors, Flavors of Errors
- logical (Boolean) operators, Operators
O
- Observer, Watching Your Processes-Watching Your Processes
- OCaml, Are You Sure You Want Erlang?
- operators, Operators
- or operator, Atomic Booleans
- ordered sets, Storing Records in Erlang Term Storage
- orelse operator, Atomic Booleans
- OS X, starting Erlang in, Firing It Up
- OTP (Open Telecom Platform), Getting Started with OTP-Packaging an Application
- overwriting values, A Key Feature: Overwriting Values
P
- packaging an application, Packaging an Application-Packaging an Application
- Pascal’s triangle, Building a List of Lists-Building a List of Lists
- pattern matching
- people (see users)
- percent sign (%), Documenting Code
- pid (process identifier), The Shell Is a Process
- process identifier (pid), The Shell Is a Process
- process(es), Playing with Processes-Breaking Things and Linking Processes
- communication between, Processes Talking Amongst Themselves-Processes Talking Amongst Themselves
- defined, Playing with Processes
- error handling, When Processes Break, Breaking Things and Linking Processes-Breaking Things and Linking Processes
- ETS, ETS Tables and Processes-ETS Tables and Processes
- lightweight, Lightweight Processes
- linking, Breaking Things and Linking Processes-Breaking Things and Linking Processes
- messages and, Breaking Things and Linking Processes
- Observer tool for, Watching Your Processes-Watching Your Processes
- registering, Registering a Process
- shell as, The Shell Is a Process-The Shell Is a Process
- spawning from modules, Spawning Processes from Modules-Spawning Processes from Modules
- process-to-process communication, Processes Talking Amongst Themselves-Processes Talking Amongst Themselves
R
- record declarations, Setting Up Records, Creating Services with gen_server
- records, From Tuples to Records-Using Records in Functions and Modules
- recursion
- refactoring, Testing, Analyzing, and Refactoring
- registering a process, Registering a Process
- reserved words, Reserved Words
- return values, recursion with, Recursing with Return Values-Recursing with Return Values
- Riak, Data Storage
- runtime errors, Flavors of Errors, Catching Runtime Errors as They Happen-Catching Runtime Errors as They Happen
- runtime system (see Erlang runtime system (ERTS))
S
- SASL (System Architecture Support Libraries), Logging Progress and Failure
- Scala, Are You Sure You Want Erlang?
- scope, variable, Functions and Variable Scope
- semicolons (with function definitions), Pattern Matching with Atoms
- services, gen_server and, Creating Services with gen_server-Creating Services with gen_server
- sets (ETS collection), Storing Records in Erlang Term Storage
- shell
- as calculator, Doing Something-Numbers in Erlang
- as process, The Shell Is a Process-The Shell Is a Process
- basics, First Steps: The Shell-Moving through Files
- clearing bound variables, Clearing Bound Variables in the Shell
- commands, Shell Commands
- creating functions with fun, Functions and Modules-Fun with fun
- moving through files, Moving through Files
- moving through history, Moving through History
- moving through text, Moving through Text
- quitting, First Steps: The Shell
- variables in, Working with Variables in the Shell-Clearing Bound Variables in the Shell
- working outside of, Moving Beyond the Erlang Shell
- side effects
- simple recursion, Simple Recursion-Recursing with Return Values
- single assignment model, Working with Variables in the Shell
- splitting lists, Splitting Lists
- state record declaration, Creating Services with gen_server
- strings, Strings-Strings
- structured data
- supervisor (OTP), A Simple Supervisor-A Simple Supervisor, OTP Templates
- synchronous communications, Creating Services with gen_server
- syntax, Erlang, A Note on Erlang Syntax
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.