Skip to content

Commit

Permalink
Merge pull request #3155 from WalterBright/enhance-index
Browse files Browse the repository at this point in the history 
add missing information to index
  • Loading branch information
@yebblies
yebblies committed Apr 7, 2015
2 parents c402d74 + ced02fb commit e1cd326
Showing 1 changed file with 88 additions and 99 deletions.
187 changes: 88 additions & 99 deletions index.d
View file
Expand Up @@ -67,7 +67,13 @@ $(BOOKTABLE ,
$(LINK2 std_zip.html, std.zip)$(BR)
$(LINK2 std_zlib.html, std.zlib)
)
$(TD Modules for reading/writing different data formats.
$(TD
Encoding / decoding Base64 format$(BR)
Read Comma Separated Values and its variants from an input range of $(CODE dchar)$(BR)
Read/write data in JSON format$(BR)
Read/write data in XML format$(BR)
Read/write data in the ZIP archive format$(BR)
Compress/decompress data using the zlib library
)
)
$(LEADINGROW Data integrity)
Expand All @@ -79,7 +85,12 @@ $(BOOKTABLE ,
$(LINK2 std_digest_ripemd.html, std.digest.ripemd)$(BR)
$(LINK2 std_digest_sha.html, std.digest.sha)$(BR)
)
$(TD Hash algorithms for verifying data integrity.
$(TD
Cyclic Redundancy Check (32-bit) implementation$(BR)
Compute digests such as md5, sha1 and crc32$(BR)
Compute MD5 hash of arbitrary data$(BR)
Compute RIPEMD-160 hash of arbitrary data$(BR)
Compute SHA1 and SHA2 hashes of arbitrary data
)
)
$(LEADINGROW Date & time)
Expand All @@ -88,9 +99,9 @@ $(BOOKTABLE ,
$(LINK2 std_datetime.html, std.datetime)$(BR)
$(LINK2 core_time.html, core.time)
)
$(TD $(D std.datetime) provides convenient access to date and time
representations.$(BR)
$(D core.time) implements low-level time primitives.
$(TD
Provides convenient access to date and time representations.$(BR)
Implements low-level time primitives.
)
)
$(LEADINGROW Exception handling)
Expand All @@ -99,8 +110,9 @@ $(BOOKTABLE ,
$(LINK2 std_exception.html, std.exception)$(BR)
$(LINK2 core_exception.html, core.exception)
)
$(TD $(D std.exception) implements routines related to exceptions.
$(D core.exception) defines built-in exception types and low-level
$(TD
Implements routines related to exceptions.$(BR)
Defines built-in exception types and low-level
language hooks required by the compiler.
)
)
Expand All @@ -112,6 +124,9 @@ $(BOOKTABLE ,
$(LINK2 etc_c_zlib.html, etc.c.zlib)
)
$(TD Various bindings to external C libraries.
Interface to libcurl C library.$(BR)
Interface to SQLite C library.$(BR)
Interface to zlib D library.
)
)
$(LEADINGROW I/O & File system)
Expand All @@ -122,13 +137,9 @@ $(BOOKTABLE ,
$(LINK2 std_stdio.html, std.stdio)
)
$(TD
$(D std.stdio) is the main module for I/O.$(BR)
$(D std.file) is for accessing the operating system's filesystem,
and $(D std.path) is for manipulating filesystem pathnames in a
platform-independent way.$(BR)
Note that $(D std.stream) and $(D std.cstream) are older,
deprecated modules scheduled to be replaced in the future; new
client code should avoid relying on them.
Manipulate files and directories.$(BR)
Manipulate strings that represent filesystem paths.$(BR)
Perform buffered I/O.
)
)
$(LEADINGROW Memory management)
Expand All @@ -138,10 +149,8 @@ $(BOOKTABLE ,
$(LINK2 std_typecons.html, std.typecons)$(BR)
)
$(TD
$(D core.memory) provides an API for user code to control the
built-in garbage collector.$(BR)
$(D std.typecons) contains primitives for building scoped variables
and reference-counted types.
Control the built-in garbage collector.$(BR)
Build scoped variables and reference-counted types.
)
)
$(LEADINGROW Metaprogramming)
Expand All @@ -153,8 +162,10 @@ $(BOOKTABLE ,
$(LINK2 core_demangle.html, core.demangle)
)
$(TD
These modules provide the primitives for compile-time introspection
and metaprogramming.
Extract information about types and symbols at compile time.$(BR)
Construct new, useful general purpose types.$(BR)
Construct and manipulate type tuples (aka type lists).$(BR)
Convert $(I mangled) D symbol identifiers to source representation.
)
)
$(LEADINGROW Multitasking)
Expand All @@ -172,17 +183,18 @@ $(BOOKTABLE ,
$(LINK2 core_sync_semaphore.html, core.sync.semaphore)$(BR)
$(LINK2 core_thread.html, core.thread)
)
$(TD These modules provide primitives for concurrent processing,
multithreading, synchronization, and interacting with operating
system processes.$(BR)

$(D core.atomic) provides primitives for lock-free concurrent
programming.$(BR)

$(D core.sync.*) modules provide low-level concurrent
programming building blocks.$(BR)

$(D core.thread) implements multithreading primitives.
$(TD
Low level messaging API for threads.$(BR)
High level primitives for SMP parallelism.$(BR)
Starting and manipulating processes.$(BR)
Basic support for lock-free concurrent programming.$(BR)
Synchronize the progress of a group of threads.$(BR)
Synchronized condition checking.$(BR)
Base class for synchronization exceptions.$(BR)
Mutex for mutually exclusive access.$(BR)
Shared read access and mutually exclusive write access.$(BR)
General use synchronization semaphore.$(BR)
Thread creation and management.
)
)
$(LEADINGROW Networking)
Expand All @@ -193,7 +205,11 @@ $(BOOKTABLE ,
$(LINK2 std_net_curl.html, std.net.curl)$(BR)
$(LINK2 std_net_isemail.html, std.net.isemail)
)
$(TD Utilities for networking.
$(TD
Socket primitives.$(BR)
Stream for a blocking, connected Socket.$(BR)
Networking client functionality as provided by libcurl.$(BR)
Validates an email address according to RFCs 5321, 5322 and others.
)
)
$(LEADINGROW Numeric)
Expand All @@ -206,11 +222,14 @@ $(BOOKTABLE ,
$(LINK2 std_numeric.html, std.numeric)$(BR)
$(LINK2 std_random.html, std.random)
)
$(TD These modules provide the standard mathematical functions and
numerical algorithms.$(BR)
$(D std.bigint) provides an arbitrary-precision integer type.$(BR)
$(D std.complex) provides a complex number type.$(BR)
$(D std.random) provides pseudo-random number generators.
$(TD
An arbitrary-precision integer type.$(BR)
A complex number type.$(BR)
Elementary mathematical functions (powers, roots, trigonometry),
low-level floating-point operations.$(BR)
Families of transcendental functions.$(BR)
Floating point numerics functions.$(BR)
Pseudo-random number generators.
)
)
$(LEADINGROW Paradigms)
Expand All @@ -220,12 +239,10 @@ $(BOOKTABLE ,
$(LINK2 std_algorithm.html, std.algorithm)$(BR)
$(LINK2 std_signals.html, std.signals)
)
$(TD $(D std.functional), along with the lazy algorithms of
$(D std.algorithm), provides utilities for writing functional-style
code in D.$(BR)

$(D std.signals) provides a signal-and-slots framework for
event-driven programming.
$(TD
Functions that manipulate other functions.$(BR)
Generic algorithms for processing sequences.$(BR)
Signal-and-slots framework for event-driven programming.
)
)
$(LEADINGROW Runtime utilities)
Expand All @@ -237,17 +254,12 @@ $(BOOKTABLE ,
$(LINK2 core_cpuid.html, core.cpuid)$(BR)
$(LINK2 core_memory.html, core.memory)$(BR)
)
$(TD Various modules for interacting with the execution environment and
compiler.$(BR)
$(D std.getopt) implements parsing of command-line arguments.$(BR)
$(D std.compiler) provides compiler information, mainly the
compiler vendor string and language version.$(BR)
$(D std.system) provides information about the runtime environment,
such as OS type and endianness.$(BR)
$(D core.cpuid) provides information on the capabilities of the
CPU the program is running on.$(BR)
$(D core.memory) allows user code to control the built-in garbage
collector.
$(TD
Parsing of command-line arguments.$(BR)
Host compiler vendor string and language version.$(BR)
Runtime environment, such as OS type and endianness.$(BR)
Capabilities of the CPU the program is running on.$(BR)
Control the built-in garbage collector.
)
)
$(LEADINGROW String manipulation)
Expand All @@ -265,34 +277,18 @@ $(BOOKTABLE ,
$(LINK2 std_encoding.html, std.encoding)$(BR)
$(LINK2 std_windows_charset.html, std.windows.charset)
)
$(TD $(D std.string) contains functions that work specifically with
strings.$(BR)

Many string manipulations are special cases of more generic
algorithms that work with general arrays, or generic ranges; these
are found in $(D std.array) and $(D std.algorithm).$(BR)

D strings are encoded in Unicode; $(D std.uni) provides operations
that work with Unicode strings in general, while $(D std.utf) deals
with specific Unicode encodings and conversions between them.$(BR)

$(D std.format) provides $(D printf)-style format string
formatting, with D's own improvements and extensions.$(BR)

For manipulating filesystem pathnames, $(D std.path) is
provided.$(BR)

$(D std.regex) is a very fast library for string matching and
substitution using regular expressions.$(BR)

$(D std.ascii) provides routines specific to the ASCII subset of
Unicode.

Windows-specific character set support is provided by
$(D std.windows.charset).

Rudimentary support for other string encodings is provided by
$(D std.encoding).
$(TD
Algorithms that work specifically with strings.$(BR)
Manipulate builtin arrays.$(BR)
Generic algorithms for processing sequences.$(BR)
Fundamental Unicode algorithms and data structures.$(BR)
Encode and decode UTF-8, UTF-16 and UTF-32 strings.$(BR)
Format data into strings.$(BR)
Manipulate strings that represent filesystem paths.$(BR)
Regular expressions.$(BR)
Routines specific to the ASCII subset of Unicode.$(BR)
Handle and transcode between various text encodings.$(BR)
Windows specific character set support.
)
)
$(LEADINGROW Type manipulations)
Expand All @@ -303,31 +299,24 @@ $(BOOKTABLE ,
$(LINK2 std_bitmanip.html, std.bitmanip)$(BR)
$(LINK2 core_bitop.html, core.bitop)$(BR)
)
$(TD $(D std.conv) provides powerful automatic conversions between
built-in types as well as user-defined types that implement
standard conversion primitives.$(BR)

$(D std.typecons) provides various utilities for type construction
and compile-time type introspection. It provides facilities for
constructing scoped variables and reference-counted types, as well
as miscellaneous useful generic types such as tuples and
flags.$(BR)

$(D std.bitmanip) provides various bit-level operations, bit
arrays, and bit fields. $(D core.bitop) provides low-level bit
manipulation primitives.$(BR)
$(TD
Convert types from one type to another.$(BR)
Type constructors for scoped variables, ref counted types, etc.$(BR)
High level bit level manipulation, bit arrays, bit fields.$(BR)
Low level bit manipulation.
)
)
$(LEADINGROW Vector programming)
$(TR
$(TD
$(LINK2 core_simd.html, core.simd)$(BR)
)
$(TD The $(D core.simd) module provides access to SIMD intrinsics in
the compiler.)
$(TD
SIMD intrinsics
)
)
)

Macros:
TITLE=Phobos Runtime Library
WIKI=Phobos
TITLE=Phobos Runtime Library
WIKI=Phobos

0 comments on commit e1cd326

Please sign in to comment.