APPENDIX A Conventions Every programming language has its own conventions for ensuring a collective understanding and consistency with the design of code written in that language. Some conventions are also able to transition pretty consistently across different programming languages due to the fact that there are groupings of languages (such as C) where the syntax is similar, and so the conventions make sense when applied across multiple languages. For example, if you’ve ever written a for loop (of any variety), then chances are you’ll know of the variable identifiers i, j, and k being used as characters for each nested loop level (see Listing A-1, which utilizes the JavaScript language syntax to demonstrate a for loop). Listing A-1. Example of i, j, and k Variables in a for Loop for (i = 0; i < condition; i++) { for (j = 0; j < condition; j++) { for (k = 0; k < condition; k++) { // code } } } ■■Note i, j, and k are typically used for a few reasons (depending on who you talk to): i and j have been used in mathematics for a very long time, and so the transition of math to programming persisted. On a practical level, i is sometimes interpreted to stand for integer, and so when needing a nested level, it made sense to start moving up the alphabet to j, then k. Clojure has similar naming conventions. © Mark McDonnell 2017 185 M. McDonnell, Quick Clojure, DOI 10.1007/978-1-4842-2952-1 APPENDIX A ■ CoNVENTIoNS Functions • f, g, h: function input (notice similarity with i, j, k, where now f represents function) • n: integer input (usually a size) • i: integer index • x, y: numbers • s: string input • xs: considered a plural, or sequence, of x • coll: a collection (or sequence) • pred: a predicate closure • & more: variadic input • *var*: dynamic variables should be wrapped in asterisks (also referred to as “ear muffs”) Macros • expr: an expression • body: a macro body • binding: a macro binding vector 186 APPENDIX B Writing Clojure with Vim There are many text/code editors available on the market, each with its pros and cons and justifications as to why you should use it. Here is a short list that I managed to put together of editors that had some form of Clojure support available within them (or via plugins): • Atom: Proto REPL • Emacs: CIDER • Vim: Fireplace • IntelliJ (Java IDE): Cursive • Light Table: Built-in Interactive Clojure IDE As you can probably tell by the title of this appendix, I’m a Vim user. Now, I’m not going to sell you on the virtues of why I feel Vim is the best editor to use, as I’ve already done that by writing a book on the topic called Pro Vim1 (published by Apress). Also, Vim does have quite a steep learning curve, so it’s not ideal for everyone. That being said, if you’re interested in using Vim for Clojure and/or you’re already a Vim user, then stick with me while I cover the different plugins and configuration settings you’ll need in order to get working efficiently with Clojure in Vim. To start with, we need the following plugins installed: • vim-fireplace2 • vim-sexp-mappings-for-regular-people3 • rainbow_parentheses.vim4 Now I'm going to run through these plugins in reverse order, because the preceding list is actually in priority order (i.e., the Fireplace plugin is essential, but the next two plugins, although very useful, strictly speaking aren’t “essential” in order to have something working). 1http://www.apress.com/gb/book/9781484202517 2https://github.com/tpope/vim-fireplace/ 3https://github.com/tpope/vim-sexp-mappings-for-regular-people/ 4https://github.com/kien/rainbow_parentheses.vim © Mark McDonnell 2017 187 M. McDonnell, Quick Clojure, DOI 10.1007/978-1-4842-2952-1 APPENDIX B ■ WRITING CLOJURE wITH VIM But also, the complexity of each plugin matches its priority and importance. So, for example, the lowest-priority plugin, Rainbow Parentheses, is also the easiest to describe. Rainbow Parentheses This plugin is very easy to work with. It takes all your boring parentheses and makes them color coded (that’s it). The point is to make it easier to decipher the start and end of a particular Clojure form. You might wonder: Why bother? But trust me, even with a Clojure file format theme, your eyes will still struggle to pick out specific forms in your code (especially because as your code becomes more complex you’ll find there are lots of nested parentheses to deal with), and so having them rainbow colored is a real blessing. Sexp Mappings for Regular People In a Lisp-based language, you have what are referred to as S-expressions.5 In layman’s terms, these are simply part of a notation format, and you see them in Lisp-based languages as parentheses wrapped around expressions (this comes back to the “code as data” mantra we discussed at the beginning of the book, where code represents the same underlying data structure). So, this plugin allows you to manipulate your Clojure code (e.g., the Clojure “forms”). But it’s important to not get this plugin confused with another Vim plugin called Sexp,6 which is a valid plugin for manipulating S-expressions. But the plugin we’re interested in here is actually an extension of Sexp, just with more idiomatic key bindings for terminal- based Vim users. There are two primary functions of this plugin: 1. Automatic Parentheses Matching 2. List Manipulation The first item is fairly straightforward: if you type an opening parenthesis (, then Vim will automatically insert a closing parenthesis ) after it and will then place your cursor in-between the parentheses. This is great because it saves you from forgetting to add either an opening or closing parenthesis yourself, which could accidentally cause your program to trigger an error (this can be quite an annoying bug to have to fix, as it can be difficult to identify when dealing with heavily nested forms). The second item, list manipulation, is the crux of this plugin. It provides the following key bindings: • <f and >f: move “form” left or right • <e and >e: move “element” left or right 5https://en.wikipedia.org/wiki/S-expression 6https://github.com/guns/vim-sexp 188 APPENDIX B ■ WRITING CLOJURE wITH VIM • <( and >(: move “opening parenthesis” left or right • <) and >): move “closing parenthesis” left or right • <I and >I: move “insertion” left or right Let’s do some quick demonstrations to highlight how these key bindings work. We’ll assume we’re dealing with the following code (see Listing B-1), and after each manipulation we’ll compare back to Listing B-1 to see how things have changed. Listing B-1. A Simple Function That Handles a Calculation (def myfn [f g h] (* h (+ f g))) Form Manipulation The key bindings <f and >f affect the innermost form your cursor currently resides within. So, if your cursor is inside (or on top of) the form (+ f g) and you execute <f, then you’ll find that the form moves to the left (see Listing B-2 for the new layout). Listing B-2. Result from Form Manipulation (def myfn [f g h] (* (+ f g) h)) Element Manipulation Similar to form manipulation, if your cursor is on top of the h symbol (i.e., “element”) and you execute >e on the original example code, then you’ll find that it moves the element to the right (see Listing B-3 for the new layout). Listing B-3. Result from Element Manipulation (def myfn [f g h] (* (+ f g) h)) ■■Note You’ll see that Listing B-3 reached the same output as Listing B-2, but it was achieved by two different mechanisms. Parenthesis Manipulation If your cursor is on top of (or inside of) the ( character from (+ f g), and you execute 2<( on the original example code, then you’ll find that it moves the parenthesis two places to the left (see Listing B-4 for the new layout). In this example, I’ve used a Vim count of 2 with <(, so it is run twice. 189 APPENDIX B ■ WRITING CLOJURE wITH VIM Listing B-4. Result from Parenthesis Manipulation (def myfn [f g h] ((* h + f g))) ■■Note This code would now cause an error when run, but I’ve done this to demonstrate the functionality (because of the automatic parenthesis-insertion feature, I very rarely need to manipulate an individual parenthesis). Insertion Manipulation If your cursor is on top of (or inside of) a form, then executing <I will move your cursor to the start of the form and automatically enter Vim’s INSERT mode. As an example, place your cursor inside (+ f g) and execute <I; you should see that the cursor is placed before the +, ready for you to start typing. Similarly, if you were to place your cursor inside the (* h ...), making sure it’s outside of the (+ f g) form (which is nested inside), and then execute >I; you would see that the cursor is placed just before the form’s closing parenthesis. This feature is useful for quickly getting to the start and end of long and complex forms. Fireplace The Fireplace plugin is the main event. With this plugin, you can connect Vim to a networked REPL (Leiningen, in our case, but there are others you can use if you want to) and dynamically evaluate your Clojure code right from within Vim. This would result in your getting instant feedback on the code you’ve written and how it will actually behave.