ebook img

Quick Clojure. Effective Functional Programming PDF

205 Pages·2017·1.513 MB·english
Save to my drive
Quick download
Download
Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.

Preview Quick Clojure. Effective Functional Programming

Quick Clojure Effective Functional Programming Mark McDonnell Quick Clojure: Effective Functional Programming Mark McDonnell Southend-on-Sea, UK ISBN-13 (pbk): 978-1-4842-2951-4 ISBN-13 (electronic): 978-1-4842-2952-1 DOI 10.1007/978-1-4842-2952-1 Library of Congress Control Number: 2017952537 Copyright © 2017 by Mark McDonnell Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book's product page, located at www.apress.com/ 9781484229514. For more detailed information, please visit http://www.apress.com/ source-code. Contents at a Glance Introduction� �����������������������������������������������������������������������������������xxi ■ Chapter 1: What Is Clojure? ������������������������������������������������������������1 ■ Chapter 2: Data Structures and Syntax ������������������������������������������9 ■ Chapter 3: Functional Programming ��������������������������������������������29 ■ Chapter 4: Sequences �������������������������������������������������������������������45 ■ Chapter 5: Functions ��������������������������������������������������������������������55 ■ Chapter 6: Destructuring ��������������������������������������������������������������79 ■ Chapter 7: Pattern Matching ��������������������������������������������������������85 ■ Chapter 8: Concurrency ����������������������������������������������������������������95 ■ Chapter 9: Namespaces ��������������������������������������������������������������125 ■ Chapter 10: Macros ��������������������������������������������������������������������137 ■ Chapter 11: Object Orientation ���������������������������������������������������147 ■ Chapter 12: Leiningen�����������������������������������������������������������������155 ■ Chapter 13: Command-Line Applications �����������������������������������175 ■ Appendix A: Conventions ������������������������������������������������������������185 ■ Appendix B: Writing Clojure with Vim ����������������������������������������187 Index ����������������������������������������������������������������������������������������������195 Contents Introduction� �����������������������������������������������������������������������������������xxi ■ Chapter 1: What Is Clojure? ������������������������������������������������������������1 Why Should You Care? �����������������������������������������������������������������������������2 The Name? ����������������������������������������������������������������������������������������������3 Getting Started ����������������������������������������������������������������������������������������3 Documentation ����������������������������������������������������������������������������������������6 Summary �������������������������������������������������������������������������������������������������7 ■ Chapter 2: Data Structures and Syntax ������������������������������������������9 List���������������������������������������������������������������������������������������������������������10 Vector ����������������������������������������������������������������������������������������������������13 Map �������������������������������������������������������������������������������������������������������18 Keywords ����������������������������������������������������������������������������������������������������������������20 Keys, Values, and Replacement ������������������������������������������������������������������������������21 Set ���������������������������������������������������������������������������������������������������������23 Vars and Symbols ����������������������������������������������������������������������������������24 Assigning Functions �����������������������������������������������������������������������������������������������25 Temp Variables �������������������������������������������������������������������������������������������������������26 Dynamic Variables ��������������������������������������������������������������������������������������������������27 Summary �����������������������������������������������������������������������������������������������28 ■ Chapter 3: Functional Programming ��������������������������������������������29 Immutability ������������������������������������������������������������������������������������������29 Referential Transparency �����������������������������������������������������������������������30 First-class Functions �����������������������������������������������������������������������������30 Complement �����������������������������������������������������������������������������������������������������������32 Apply �����������������������������������������������������������������������������������������������������������������������32 Map �������������������������������������������������������������������������������������������������������������������������33 Reduce ��������������������������������������������������������������������������������������������������������������������34 Filter �����������������������������������������������������������������������������������������������������������������������35 Comp ����������������������������������������������������������������������������������������������������������������������35 Partial Application ���������������������������������������������������������������������������������38 Recursive Iteration ��������������������������������������������������������������������������������40 Composability ����������������������������������������������������������������������������������������42 Summary �����������������������������������������������������������������������������������������������43 ■ Chapter 4: Sequences �������������������������������������������������������������������45 List Comprehension �������������������������������������������������������������������������������46 Sequence Abstraction ���������������������������������������������������������������������������47 Lazy Sequences ������������������������������������������������������������������������������������49 lazy-seq ������������������������������������������������������������������������������������������������������������������50 Summary �����������������������������������������������������������������������������������������������53 ■ Chapter 5: Functions ��������������������������������������������������������������������55 Anonymous Function Shorthand �����������������������������������������������������������55 Pre and Post Conditions ������������������������������������������������������������������������56 clojure�core ��������������������������������������������������������������������������������������������58 Map Construction ���������������������������������������������������������������������������������������������������58 Pipelining ����������������������������������������������������������������������������������������������������������������59 Dropping Values ������������������������������������������������������������������������������������������������������61 Code Comments �����������������������������������������������������������������������������������������������������62 Endless Cycle ���������������������������������������������������������������������������������������������������������63 Uniqueness �������������������������������������������������������������������������������������������������������������64 Predicate Functions ������������������������������������������������������������������������������������������������64 Collection Extraction �����������������������������������������������������������������������������������������������66 String Formatting ���������������������������������������������������������������������������������������������������67 Frequency ���������������������������������������������������������������������������������������������������������������68 Zipping Values ��������������������������������������������������������������������������������������������������������68 Interposing Values ��������������������������������������������������������������������������������������������������70 Partitioning Data �����������������������������������������������������������������������������������������������������70 Simple Parallelization ���������������������������������������������������������������������������������������������72 Repeating Yourself ��������������������������������������������������������������������������������������������������73 Basic I/O �����������������������������������������������������������������������������������������������������������������73 clojure�string �����������������������������������������������������������������������������������������74 Checking for Whitespace ����������������������������������������������������������������������������������������74 Beginnings and Endings �����������������������������������������������������������������������������������������75 Trimming Whitespace ���������������������������������������������������������������������������������������������76 Summary �����������������������������������������������������������������������������������������������77 ■ Chapter 6: Destructuring ��������������������������������������������������������������79 Summary �����������������������������������������������������������������������������������������������83 ■ Chapter 7: Pattern Matching ��������������������������������������������������������85 core�match ��������������������������������������������������������������������������������������������85 Example: FizzBuzz ��������������������������������������������������������������������������������������������������86 Backreferences�������������������������������������������������������������������������������������������������������87 Matching Literals ����������������������������������������������������������������������������������������������������88 Matching Data Structures ���������������������������������������������������������������������������������������89 Safeguarding ����������������������������������������������������������������������������������������������������������90 Polymorphism ���������������������������������������������������������������������������������������92 Summary �����������������������������������������������������������������������������������������������94 ■ Chapter 8: Concurrency ����������������������������������������������������������������95 Retriable ������������������������������������������������������������������������������������������������96 Coordinated �������������������������������������������������������������������������������������������96 Asynchronous ����������������������������������������������������������������������������������������96 Thread Safe �������������������������������������������������������������������������������������������97 Delay �����������������������������������������������������������������������������������������������������97 Promise �������������������������������������������������������������������������������������������������98 Future ����������������������������������������������������������������������������������������������������99 Atom ����������������������������������������������������������������������������������������������������100 Lock �����������������������������������������������������������������������������������������������������103 Deadlock ���������������������������������������������������������������������������������������������������������������104 Livelock ����������������������������������������������������������������������������������������������������������������104 Agent ���������������������������������������������������������������������������������������������������105 Without wait/wait-for��������������������������������������������������������������������������������������������106 Using wait �������������������������������������������������������������������������������������������������������������107 Using wait-for �������������������������������������������������������������������������������������������������������107 Agent Errors ����������������������������������������������������������������������������������������������������������108 Transactions ����������������������������������������������������������������������������������������110 dosync/ref/alter ����������������������������������������������������������������������������������������������������110 ref-set �������������������������������������������������������������������������������������������������������������������110 STM Restart Policy������������������������������������������������������������������������������������������������111 Nested Transactions ���������������������������������������������������������������������������������������������113 ensure �������������������������������������������������������������������������������������������������������������������113 commute���������������������������������������������������������������������������������������������������������������115 Channels����������������������������������������������������������������������������������������������116 Go Blocks ��������������������������������������������������������������������������������������������������������������118 Thread Function ����������������������������������������������������������������������������������������������������119 Distinction �������������������������������������������������������������������������������������������������������������120 Alternate ���������������������������������������������������������������������������������������������������������������120 Buffered Channels ������������������������������������������������������������������������������������������������121 Sliding/Dropping Buffered Channels ��������������������������������������������������������������������121 Timeout Channels �������������������������������������������������������������������������������������������������122 Summary ���������������������������������������������������������������������������������������������123 ■ Chapter 9: Namespaces ��������������������������������������������������������������125 What Is a Namespace? ������������������������������������������������������������������������126 Loading Namespaced Files �����������������������������������������������������������������127 Interning ����������������������������������������������������������������������������������������������128 Root Bindings �������������������������������������������������������������������������������������������������������129 Dynamic Variables ������������������������������������������������������������������������������������������������130 Detour Over… ������������������������������������������������������������������������������������������������������130 foo�core �����������������������������������������������������������������������������������������������������������������131 foo�bar ������������������������������������������������������������������������������������������������������������������131 foo�baz ������������������������������������������������������������������������������������������������������������������132 :require �����������������������������������������������������������������������������������������������������������������132 :as �������������������������������������������������������������������������������������������������������������������������133 :refer ���������������������������������������������������������������������������������������������������������������������133 :all �������������������������������������������������������������������������������������������������������������������������134 :use �����������������������������������������������������������������������������������������������������������������������135 Anything Else? ������������������������������������������������������������������������������������������������������136 Summary ���������������������������������������������������������������������������������������������136 ■ Chapter 10: Macros ��������������������������������������������������������������������137 Expanding All the Way Down ���������������������������������������������������������������139 Writing Your Own Macros ��������������������������������������������������������������������140 Quoting ' ����������������������������������������������������������������������������������������������140 Syntax Quoting ` ����������������������������������������������������������������������������������141 Unquoting ~ ����������������������������������������������������������������������������������������141 Unquote Splicing ~@ ��������������������������������������������������������������������������142 Generating Symbols gensym/# �����������������������������������������������������������143 Macro Dissection ���������������������������������������������������������������������������������143 Summary ���������������������������������������������������������������������������������������������145 ■ Chapter 11: Object Orientation ���������������������������������������������������147 Java Interop �����������������������������������������������������������������������������������������147 defprotocol ������������������������������������������������������������������������������������������148 deftype ������������������������������������������������������������������������������������������������148 defrecord ���������������������������������������������������������������������������������������������150 Reify ����������������������������������������������������������������������������������������������������152 Summary ���������������������������������������������������������������������������������������������152

See more

The list of books you might like

Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.