Chapter 1. Why Nim?
Listing 1.1. Style insensitivity
Listing 1.2. Style insensitivity and type identifiers
Listing 1.3. Iterating from 0 to 9 in Nim
Listing 1.4. Iterating from 0 to 9 in C++
Listing 1.5. Barking dog modeled using OOP in Python
Listing 1.6. Barking dog modeled using procedural programming in Nim
Listing 1.7. Iterating over a sequence using functional programming in Nim
Listing 1.8. Iterating over a sequence using a procedural style in Nim
Chapter 2. Getting started
Listing 2.7. Character literals
Listing 2.9. Using anonymous procedures
Listing 2.10. Raising an exception
Listing 2.11. The try statements
Listing 2.12. Handling an exception using a try statement
Chapter 3. Writing a chat application
Listing 3.1. Conversation between me, John, and Grace about Game of Thrones
Listing 3.2. Typical directory layout for a Nim project
Listing 3.3. Reading command-line parameters
Listing 3.4. Reading from the standard input stream
Listing 3.5. Spawning readLine in a new thread
Listing 3.6. Message type definition and proc stub
Listing 3.7. A representation of a message in JSON
Listing 3.8. Parsing JSON in protocol.nim
Listing 3.9. The mapping between JSON values and the JsonNodeKind type
Listing 3.10. Assigning parsed data to the result variable
Listing 3.11. Testing your new functionality
Listing 3.12. Creating a new message
Listing 3.13. Standard library imports and type definitions
Listing 3.14. Simple Future[int] example
Listing 3.15. Reading files asynchronously in Node
Listing 3.16. Reading files asynchronously in Nim
Listing 3.17. Reading files and writing to them in sequence using await
Listing 3.18. Creating a server socket and accepting connections from clients
Listing 3.19. Creating a new Client instance for each connection
Listing 3.20. Receiving messages from a client
Listing 3.21. The full server implementation so far
Listing 3.22. Sending messages on to other clients
Listing 3.23. The processMessages procedure after listing 3.22 is inserted
Listing 3.24. The client’s connect procedure
Listing 3.25. Reading from standard input asynchronously
Listing 3.26. The final client implementation
Listing 3.27. Conversation between John, Grace, and me about Game of Thrones
Chapter 4. A tour through the standard library
Listing 4.1. Module example.nim
Listing 4.3. Some of the directories in Nim’s configuration file
Listing 4.4. Importing from a subdirectory
Listing 4.5. Module example2.nim
Listing 4.6. Disambiguating identifiers
Listing 4.7. Importing modules into their own namespace
Listing 4.8. Importing only some of the definitions from a module
Listing 4.9. Excluding some definitions when importing
Listing 4.10. Uniform Function Call Syntax
Listing 4.11. Defining a list of integers and strings
Listing 4.12. Creating a hash table
Listing 4.13. Using a custom type as a key in a hash table
Listing 4.14. Defining a hash procedure for custom types
Listing 4.15. Modeling an access list using a HashSet
Listing 4.16. Sorting using the algorithm module
Listing 4.17. The definition of the generic cmp procedure
Listing 4.18. Write "Some Data" to file.txt in the home directory
Listing 4.19. Path-manipulation procedures
Listing 4.20. Displaying the contents of the home directory
Listing 4.21. Using execCmdEx to determine some information about the OS
Listing 4.22. Retrieving command-line arguments using paramStr
Listing 4.23. Parsing the flag using substr
Listing 4.24. Parsing the flag using split
Listing 4.25. Parsing the flag using parseopt
Listing 4.26. Requesting the Nim website using the httpclient module
Chapter 5. Package management
Listing 5.5. The beginnings of NimbleExample.nimble
Listing 5.6. Using the bigints package in the math module
Listing 5.7. Adding a dependency on the bigints package
Listing 5.8. Commands to upload the NimbleExample package to GitHub
Chapter 6. Parallelism
Listing 6.1. Mutating a global variable using a Thread
Listing 6.2. Passing data to a thread safely
Listing 6.3. Passing multiple values to a thread
Listing 6.4. Executing multiple threads
Listing 6.5. First possible output when the code in listing 6.4 is executed
Listing 6.6. Second possible output when the code in listing 6.4 is executed
Listing 6.7. Executing multiple threads using spawn
Listing 6.8. Reading input from the terminal with spawn
Listing 6.9. Exceptions in a spawned procedure
Listing 6.10. Parsing data with the re module
Listing 6.11. Parsing using split
Listing 6.12. Parsing using parseutils
Listing 6.13. Iterating over each line in a file
Listing 6.14. Parsing each line in a file
Listing 6.15. The output of sequential_counts.nim
Listing 6.16. The finished sequential_counts.nim
Listing 6.17. Output for sequential_counts.nim
Listing 6.18. The top section of parallel_counts.nim
Listing 6.19. The middle section of parallel_counts.nim
Listing 6.20. The last section of parallel_counts.nim
Listing 6.21. Race condition with shared memory
Listing 6.22. Attempting to access a guarded global variable from a thread
Listing 6.23. Incrementing a global variable with a lock
Listing 6.24. Initializing a channel using open
Listing 6.25. Sending and receiving data through a channel
Listing 6.26. parallel_incrementer.nim implemented using channels
Chapter 7. Building a Twitter clone
Listing 7.1. A / route defined using Jester
Listing 7.2. A simple HTTP GET request
Listing 7.3. Tweeter’s directory structure
Listing 7.4. The Tweeter.nimble file
Listing 7.5. The final Tweeter.nimble file
Listing 7.6. A simple Jester test
Listing 7.7. The types that store a Tweeter message and user information
Listing 7.8. Representing the data in figure 7.9 using an instance of Message
Listing 7.9. Representing a user using an instance of User
Listing 7.10. Connecting to a SQLite database
Listing 7.11. Creating tables in a SQLite database
Listing 7.12. The Database type
Listing 7.13. Implementing the post, follow, and create procedures
Listing 7.14. Implementing the findUser and findMessages procedures
Listing 7.15. The setup and close procedures destined for database.nim
Listing 7.16. The new implementation of createDatabase.nim
Listing 7.17. A test of the database module
Listing 7.18. Using a Nim filter to generate HTML
Listing 7.19. Escaping special characters in views/user.nim
Listing 7.20. The second renderUser procedure
Listing 7.21. Final views/user.nim with the new renderMessages procedure
Listing 7.22. Implementing the renderMain procedure
Listing 7.23. The implementation of renderLogin
Listing 7.24. The implementation of renderTimeline
Listing 7.25. The final code of general.nim
Listing 7.26. The /login route
Listing 7.28. The /createMessage route
Listing 7.30. The userLogin procedure
Listing 7.31. The new implementations of the / and user routes
Listing 7.32. The /follow route
Chapter 8. Interfacing with other languages
Listing 8.2. Wrapping struct tm
Listing 8.3. A complete time and localtime wrapper
Listing 8.4. Defining the shared library filename conditionally
Listing 8.5. Wrapping the four necessary types
Listing 8.6. The SDL C prototypes that will be wrapped in this section
Listing 8.7. Wrapping the procedures in the sdl module
Listing 8.8. An SDL application implemented using the sdl wrapper
Listing 8.9. Using the Canvas API in JavaScript
Listing 8.10. Wrapping the Canvas API
Chapter 9. Metaprogramming
Listing 9.1. Modeling the Simple AST shown in figure 9.5
Listing 9.2. A simplified AST for 5 * (5 + 10) displayed using an indentation-based format
Listing 9.3. The Nim AST for 5 * (5 + 10) displayed using an indentation-based format
Listing 9.4. Creating the Nim AST of 5 * (5 + 10)
Listing 9.5. A macro that emits 5 * (5 + 10)
Listing 9.6. A simple config macro
Listing 9.7. The AST of the MyAppConfig type definition
Listing 9.8. Generating the AST for a type definition
Listing 9.9. Converting a list of call statements to a list of nnkIdentDefs nodes
Appendix B. Installing Nim
3.144.123.147