book

Introducing Erlang

by Simon St. Laurent

January 2013

Beginner to intermediate

204 pages

4h 26m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Who This Book Is ForWho This Book Is Not ForWhat This Book Will Do For YouHow This Book WorksWhy I Wrote This BookOther ResourcesEtudes for ErlangAre You Sure You Want Erlang?Erlang Will Change YouConventions Used in This BookA Note on Erlang SyntaxUsing Code ExamplesHelp This Book GrowPlease Use It For GoodSafari® Books OnlineHow to Contact UsContent UpdatesApril 2, 2013Acknowledgments
InstallationFiring It UpFirst Steps: The ShellMoving through TextMoving through HistoryMoving through FilesDoing SomethingCalling FunctionsNumbers in ErlangWorking with Variables in the ShellSeeing Your Bound VariablesClearing Bound Variables in the Shell
Fun with funDefining ModulesFrom Module to FunFunctions and Variable ScopeModule DirectivesDocumenting CodeDocumenting ModulesDocumenting FunctionsDocumenting Your Application
AtomsPattern Matching with AtomsAtomic BooleansGuardsUnderscoring That You Don’t CareAdding Structure: TuplesPattern Matching with TuplesProcessing Tuples
Logic Inside of FunctionsEvaluating CasesIf This, Then ThatVariable Assignment in case and if ConstructsThe Gentlest Side Effect: io:formatSimple RecursionCounting DownCounting UpRecursing with Return Values
StringsAsking Users for InformationGathering TermsGathering CharactersReading Lines of Text
List BasicsSplitting Lists into Heads and TailsProcessing List ContentCreating Lists with Heads and TailsMixing Lists and TuplesBuilding a List of Lists
Simple Higher-Order FunctionsCreating New Lists with Higher-Order FunctionsReporting on a ListRunning List Values Through a FunctionFiltering List ValuesBeyond List ComprehensionsTesting ListsSplitting ListsFolding Lists
The Shell Is a ProcessSpawning Processes from ModulesLightweight ProcessesRegistering a ProcessWhen Processes BreakProcesses Talking Amongst ThemselvesWatching Your ProcessesBreaking Things and Linking Processes

Flavors of ErrorsCatching Runtime Errors as They HappenRaising Exceptions with throwLogging Progress and FailureDebugging through a GUITracing MessagesWatching Function Calls
From Tuples to RecordsSetting Up RecordsCreating and Reading RecordsUsing Records in Functions and ModulesStoring Records in Erlang Term StorageCreating and Populating a TableSimple QueriesA Key Feature: Overwriting ValuesETS Tables and ProcessesNext StepsStoring Records in MnesiaStarting up MnesiaCreating TablesReading DataQuery List Comprehensions
Creating Services with gen_serverA Simple SupervisorPackaging an Application
Moving Beyond the ShellDistributed ComputingProcessing Binary DataInput and OutputTesting, Analyzing, and RefactoringNetworking and the WebData StorageExtending ErlangLanguages Built on ErlangCommunitySharing the Gospel of Erlang
Shell CommandsReserved WordsOperatorsGuard ComponentsCommon FunctionsStrings and FormattingData Types for Documentation and Analysis

Content preview from Introducing Erlang

Chapter 6. Lists

Erlang is great at handling lists, long series of similar (or not) values. List processing makes it easy to see the value of recursion, and offers opportunities to get a lot of work done for very little effort.

List Basics

An Erlang list is an ordered set of elements. Generally you will process a list in order, from the first item (the head) to the last item, though there are times when you may want to grab a particular item from the list. Erlang also provides built-in functions for manipulating lists when you don’t want to go through the entire sequence.

Erlang syntax encloses lists in square brackets and separates elements with commas. A list of numbers might look like the following:

[1,2,4,8,16,32]

The elements can be of any type, including numbers, atoms, tuples, strings, and other lists. When you’re starting out, it’s definitely easiest to work with lists that contain only a single type of element, rather than mixing all the possibilities, but Erlang itself has no such constraint. There is also no limit on the number of items a list can contain, though eventually you may find practical limits of memory.

You can pattern match with lists just as you can with other Erlang data structures:

1> [1,X,4,Y] = [1,2,4,8].
[1,2,4,8]
2> X.
2
3> Y.
8

Note

While it’s possible to use lists instead of tuples, your code will make more sense if you use tuples to handle data structures containing various kinds of data in a known structure, and lists to handle data structures containing ...