Book Image

D Cookbook

By : Adam Ruppe
Book Image

D Cookbook

By: Adam Ruppe

Overview of this book

Related Content you might be interested in

Current Title:

Small book image
D Cookbook
Adam Ruppe
May, 2014 | 362 pages
No titles found
Table of Contents (21 chapters)
D Cookbook
D Cookbook
Credits
Credits
Foreword
Foreword
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Core Tasks
Core Tasks
Introduction
Installing the compiler and writing a "Hello World" program
Adding additional modules (files) to your program
Using external libraries
Building and processing arrays
Using associative arrays to translate input
Creating a user-defined vector type
Using a custom exception type
Understanding immutability
Slicing a string to get a substring
Creating a tree of classes
2
Phobos – The Standard Library
Phobos – The Standard Library
Introduction
Performing type conversions
Finding the largest files in a directory
Creating a network client and server
Using Base64 to create a data URI
Generating random numbers
Normalizing a string and performing Unicode comparisons
Searching with regular expressions
Writing a digest utility
Using the std.zlib compression
Using the std.json module
3
Ranges
Ranges
Introduction
Using ranges when implementing an algorithm
Creating an input range
Creating an output range
Creating a higher-order range
Putting a range interface on a collection
Creating an input range over a tree structure
Using runtime polymorphic (class) ranges
Storing a range as a data member
Sorting ranges efficiently
Searching ranges
Using functional tools to query data
4
Integration
Integration
Introduction
Calling the Windows API functions
Removing the Windows console
Making Linux system calls
Writing part of a C program in D
Interfacing with C++
Using structs to mimic the C++ object structure
Communicating with external processes
Communicating with a dynamic scripting language
Using Windows' COM
5
Resource Management
Resource Management
Introduction
Avoiding the garbage collector
Making a reference-counted object
Manually managing class memory
Using scope guards to manage transactions
Creating an array replacement
Managing lent resources
Creating a NotNull struct
Using unique pointers
Using RAII and handling the limitations of class destructors
6
Wrapped Types
Wrapped Types
Introduction
Creating a struct with reference semantics
Simulating inheritance with structs
Creating a ranged integer
Creating an opaque handle type
Creating a subtyped string for i18n
Forwarding methods with opDispatch
Creating a tagged dynamic type
Creating a structure with two views into the same data
Simulating multiple inheritance with mixin templates
7
Correctness Checking
Correctness Checking
Introduction
Using assertions and exceptions
Using static asserts
Using template constraints and static if
Preventing memory corruption bugs with @safe
Leveraging const-correctness
Avoiding side effects of pure functions
Verifying object invariants and pre- and post-conditions
Unit testing your code
Documenting your code with Ddoc
Writing platform-specific code (versions) and per-client configuration modules
8
Reflection
Reflection
Introduction
Getting dynamic runtime type information
Getting a list of child classes
Determining whether a module is available
Getting a list of all methods or fields in a module or an object
Inspecting function overloads
Determining names, types, and default values of function parameters
Getting components of complex types
Using user-defined attributes
Implementing a custom lint-style check for virtual functions
Extending the runtime type information
Creating a command-line function caller
9
Code Generation
Code Generation
Introduction
Creating user-defined literals
Parsing a domain-specific language
Generating data structures from text diagrams
Automating dynamic calls with multiple dispatch
Building a lookup table
Using string parameters to change functions
Wrapping instance methods
Using opDispatch to generate properties
Duck typing to a statically-defined interface
10
Multitasking
Multitasking
Introduction
Using threads
Passing messages with std.concurrency
Processing parallel data with std.parallelism
Using fibers
Creating new processes
Exploring thread-safe, single-locking singletons
Using asynchronous I/O
11
D for Kernel Coding
D for Kernel Coding
Introduction
Running D on bare metal x86 with a stripped runtime
Adding interrupt handling to the bare metal x86 code
12
Web and GUI Programming
Web and GUI Programming
Introduction
Creating a dynamic website with cgi.d
Creating a web API with web.d
Parsing and modifying an HTML page with dom.d
Accessing a SQL database
Sending an e-mail
Writing colored output to the console
Getting real-time input from the terminal
Working with image files
Creating a graphics window to show a TV static demo
Creating an OpenGL window
Addendum
Addendum
Compiling D for ARM/Linux Raspberry Pi
Running D on bare metal ARM
Using the exponentiation operator
Getting a stack trace without throwing an exception
Finding more information about D
Index
Index

Introduction

D is designed to help make programs with fewer bugs. Its built-in support for assertions, contract programming, and unit tests help you verify your program at runtime. D's exception based error model helps us to ensure no runtime errors go unnoticed, without requiring return code to be checked after every function call.

D also provides numerous features to help you to prove correctness at compile time, from built-in function annotations to custom compile checks with static assert, which is capable of running D code with compile-time reflection to implement complex checks.

We'll also look at D's built-in support for documentation and platform versioning, which helps you to communicate that the code does what you intended, not just what you programmed.

Previous Section
End of Section 2
Next Section