saluu/handson-dlang
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

switch to markdown

Browse source
This commit is contained in:
Johannes Loher 2018-04-13 15:02:06 +02:00
parent fb04fd1db1
commit dc0a64baa8
3 changed files with 323 additions and 334 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
.gitignore vendored
View file

@ -1,9 +0,0 @@
*.aux
*.fdb_latexmk
*.fls
*.log
*.out
*.pdf
*.synctex.gz
*.toc
__latexindent_temp.tex

323
hands-on_dlang.md Normal file
View file

@ -0,0 +1,323 @@
# Hands-On DLang
## Setup
### Installing DMD and DUB
#### OS X
##### Installing with Homebrew (recommended)
```bash
brew install dmd
brew install dub
```
##### Installing locally using the install script
```bash
curl -fsS https://dlang.org/install.sh | bash -s dmd
echo "~/.dlang/dmd-2.079.0/activate" >> ~/.profile # Add dmd and dub to PATH on starting a bash shell
```
##### Installing using the installer
* Download http://downloads.dlang.org/releases/2.x/2.079.0/dmd.2.079.0.dmg.
* Open `dmd.2.079.0.dmg`
* Run `DMD2.pkg` (you might need to activate the “allow installing applications from unverified developers” option in your security settings) and install with the default settings.
#### Windows
* Download http://downloads.dlang.org/releases/2.x/2.079.0/dmd-2.079.0.exe.
* Run `dmd-2.079.0.exe` and install with the default settings (this will also install Visual Studio if you do not have it installed yet).
### Recommended editor setup
Visual Studio Code is the recommended editor, because it has the best D integration at the moment.
If you want to use another editor or IDE, that is perfectly fine.
However, instructions will only be provided for Visual Studio Code.
#### Installation of Visual Studio Code
Download and install Visual Studio Code from here: https://code.visualstudio.com/. OS X users can also install it using Homebrew:
```bash
brew tap caskroom/cask
brew cask install visual-studio-code
```
#### Extension setup
* Open the Extension view in the sidebar:
|Operating system|Shortcut |
|----------------|---------|
|OS X |⌘ + ⇧ + X|
|Windows |⌃ + ⇧ + X|
* Install the extension “D Programming Language (code-d)” (requires that git is installed).
* Restart Visual Studio Code.
## Basics
### Hello World
```D
import std.stdio;
void main() {
writeln("Hello World");
}
```
### Imports and modules
D has the concept of _modules_ and _packages_.
By importing a certain module with the `import` statement, all public symbols from module become available.
The standard library, called Phobos, is located in the `std` package.
E.g. in order to import the `file` module from Phobos, you would write:
```D
import std.file;
```
#### Selective imports
It is possible (and often good style) to import symbols selectively from a module:
```D
import std.stdio: writeln, writefln;
```
#### Scoped imports
It is not necessary to place imports at the beginning of a file.
They can be located anywhere in the code.
If they appear inside a certain scope (delimited by braces), the imported symbols are only available inside that scope.
Here is an alternative version of the hello world program:
```D
void main()
{
import std.stdio: writeln;
writeln("Hello World");
}
/* writeln is not available outside of the main function */
```
#### Imports match files and directories
The module system is entirely based on files.
E.g. `my.thing` refers to a file `thing.d` in the folder `my/`.
### Basic Types
D has the following basic types:
| Datatypes | Size |
| ------------------------------- | ------------------------------------------------------------ |
| `bool` `byte`, `ubyte`, `char` | 8-bit |
| `short`, `ushort`, `wchar` | 16-bit |
| `int`, `uint`, `dchar`, `float` | 32-bit |
| `long`, `ulong`, `double` | 64-bit |
| `real` | >= 64-bit (generally 64-bit, but 80-bit on Intel x86 32-bit) |
`char` represents UTF-8 characters, `wchar`represents UTF-16 characters, and `dchar` represents UTF-32 characters.
#### Type conversion
For integer types, automatic type conversion is only allowed if no precision is lost (e.g. `int` to `long`).
All conversion between floating point types are allowed (e.g. `double` to `float`).
Manual type conversion is achieved with the `cast` expression:
```D
long a = 1;
int b = cast(int) a;
```
#### Type properties
All types have a property `.init` to which variables of that type are initialized, if they are not initialized explicitly.
For integer types, this is `0` and for floating point types it is `nan`.
Every type also has a `.stringof` property which yields its name as a string.
Integer types have some more properties:
| Property | Description |
| -------- | ----------------------------------- |
| `.max` | The maximum value the type can hold |
| `.min` | The minimum value the type can hold |
And so do floating point types:
| Property | Description |
| ------------- | ----------------------------------------------------------- |
| `.max` | The maximum value the type can hold |
| `.min_normal` | The smallest representable normalized value that is not `0` |
| `.nan` | NaN value |
| `.infinity` | Infinity value |
| `.dig` | number of decimal digits of precisions |
| `.mant_dig` | number of bits in mantissa |
| … | |
#### Indexing
For indexing, usually the alias type `size_t` is used, which is large enough to represent an offset into all addressable memory.
### Variable declarations
Variables are declared by writing the type followed by the variable name:
```D
int myVar;
```
They can also be explicitly initialized:
```D
int myVar = 42;
```
It is also possible to declare several variables at once:
```D
int myVar, someOtherVar;
```
D has automatic type deduction, so when explicitly initializing a variable, it is not necessary to mention the type.
Instead we can use the `auto` keyword:
```D
auto myVar = 42;
```
Here is a combination of the above notations:
```D
auto myInt = 42, myFloat = 4.2f;
```
### Functions
The basic syntax for functions is very similar to C:
```D
int add(int lhs, int rhs) {
return lhs + rhs;
}
```
#### Return type deduction
A functions return type can be defined to be `auto`.
In this case, the return type will be infered.
Multiple return statements are possible, but must return compatible types.
```D
auto add(int lhs, int rhs) { // returns `int`
return lhs + rhs;
}
auto lessOrEqual(int lhs, int rhs) { // returns `double`
if (lhs <= rhs)
return 0;
else
return 1.0;
}
```
#### Default arguments
Those also work the same as in C and other languages:
```D
void plot(string msg, string color = "red") {
/* ... */
}
plot("D rocks");
plot("D rocks", "blue");
```
#### Local functions
It is possible to define functions locally (even inside other functions).
Those functions are not visible outside their parents scope.
```D
void fun() {
int local = 10;
int fun_secret() {
local++; // that's legal
}
/* … */
}
static assert(!__traits(compiles, fun_secret())); // fun_secret is not visible here
```
### Control flow
#### if…else
Very similar to how it is defined in other languages:
```D
if (a == 5) {
writeln("Condition is met");
} else if (a > 10) {
writeln("Another condition is met");
} else {
writeln("Nothing is met!");
}
```
#### switch…case
Also very similar to how it is defined in other languages, but for it works for integer types, bools and strings (which will be covered later).
```D
string myString;
/* … */
switch(myString) {
case "foo":
writeln(`Cool, myString was "foo"`);
break;
default:
writeln("Meh, myString was something boring");
break;
}
```
For integer types, it is also possible to define ranges:
```D
int c = 5;
switch(c) {
case 0: .. case 9:
writeln(c, " is within 0-9");
break; // necessary!
case 10:
writeln("A Ten!");
break;
default: // if nothing else matches
writeln("Nothing");
break;
}
```
#### Loops
`while`-, `do`…`while`- and classical `for`-loops all work the same as in C++/Java etc.
##### Breaking out of outer loops
As usual, you can break out of a loop immediately by using the `break` keyword. Additionally, you can also break out of outer loops by using labels:
```D
outer:
for (int i = 0; i < 10; ++i) {
for (int j = 0; j < 5; ++j) {
/* … */
break outer; // breaks out of the outer loop
}
}
```

325
hands-on_dlang.tex
View file

@ -1,325 +0,0 @@
\documentclass[paper=a4,parskip=half,11pt,english,oneside,open=any,draft=false]{scrreprt}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage{babel}
\usepackage{csquotes}
\usepackage{listings}
\usepackage{xcolor}
\usepackage{textcomp}
\usepackage{applekeys}
\usepackage{hyperref}
\hypersetup{pdfinfo={Title={Hands-On DLang}, Author={Johannes Loher}}}
\lstdefinestyle{D}{
language=C,
emptylines=1,
breaklines=true,
basicstyle=\footnotesize\ttfamily,
keywordstyle=\bfseries\color{green!50!black},
commentstyle=\itshape\color{white!50!black},
numbers=left,
frame=single,
showstringspaces=false
}
\lstdefinestyle{bash}{
language=bash,
emptylines=1,
breaklines=true,
basicstyle=\footnotesize\ttfamily,
numbers=left,
frame=single,
showstringspaces=false
}
\setkomafont{descriptionlabel}{\normalfont}
\begin{document}
\title{Hands-On DLang}
\author{Johannes Loher}
\date{\today}
\maketitle
\tableofcontents
\chapter{Setup}
\section{Installing DMD and DUB}
\subsection{OS X}
\subsubsection{Installing with Homebrew (recommended)}
\begin{lstlisting}[style=bash]
brew install dmd
brew install dub
\end{lstlisting}
\subsubsection{Installing locally using the install script}
\begin{lstlisting}[style=bash]
curl -fsS https://dlang.org/install.sh | bash -s dmd
echo "~/.dlang/dmd-2.079.0/activate" >> ~/.profile # Add dmd and dub to PATH on starting a bash shell
\end{lstlisting}
\subsubsection{Installing using the installer}
\begin{enumerate}
\item Download \url{http://downloads.dlang.org/releases/2.x/2.079.0/dmd.2.079.0.dmg}.
\item Open \texttt{dmd.2.079.0.dmg}.
\item Run \texttt{DMD2.pkg} (you might need to activate the \enquote{allowinstalling applications from unverified developers} option in your security settings) and install with the default settings.
\end{enumerate}
\subsection{Windows}
\begin{enumerate}
\item Download \url{http://downloads.dlang.org/releases/2.x/2.079.0/dmd-2.079.0.exe}.
\item Run \texttt{dmd-2.079.0.exe} and install with the default settings (this will also install Visual Studio if you do not have it installed yet).
\end{enumerate}
\section{Recommended editor setup}
Visual Studio Code is the recommended editor, because it has the best D integration at the moment.
If you want to use another editor or IDE, that is perfectly fine.
However, instructions will only be provided for Visual Studio Code.
\subsection{Installation of Visual Studio Code}
Download and install Visual Studio Code from here: \url{https://code.visualstudio.com/}. OS X users can also install it using Homebrew:
\begin{lstlisting}[style=bash]
brew tap caskroom/cask
brew cask install visual-studio-code
\end{lstlisting}
\subsection{Extension setup}
\begin{enumerate}
\item Open the Extension view in the sidebar:
\begin{tabular}{ll}
OS X: & \cmdkey{} + \shiftkey{} + X\\
Windows: & \ctlkey{} + \shiftkey{} + X
\end{tabular}
\item Install the extension \enquote{D Programming Language (code-d)} (requires that git is installed).
\item Restart Visual Studio Code.
\end{enumerate}
\chapter{Basics}
\section{Hello World}
\begin{lstlisting}[style=D]
import std.stdio;
void main() {
writeln("Hello World");
}
\end{lstlisting}
\section{Imports and modules}
D has the concept of \emph{modules} and \emph{packages}.
By importing a certain module with the \texttt{import} statement,all public symbols from module become available.
The standard library, called Phobos, is located in the \texttt{package}.
E.g. in order to import the \texttt{file} module from Phobos, you would write:
\begin{lstlisting}[style=D]
import std.file;
\end{lstlisting}
\subsection{Selective imports}
It is possible (and often good style) to import symbols selectively from a module:
\begin{lstlisting}[style=D]
import std.stdio: writeln, writefln;
\end{lstlisting}
\subsection{Scoped imports}
It is not necessary to place imports at the beginning of a file.
They can be located anywhere in the code.
If they appear inside a certain scope (delimited by braces), the imported symbols are only available inside that scope.
Here is an alternative version of the hello world program:
\begin{lstlisting}[style=D]
void main()
{
import std.stdio: writeln;
writeln("Hello World");
}
/* writeln is not available outside of the main function */
\end{lstlisting}
\subsection{Imports match files and directories}
The module system is entirely based on files.
E.g. \texttt{my.thing} refers to a file \texttt{thing.d} in the folder \texttt{my/}.
\section{Basic Types}
D has the following basic types:
\begin{tabular}{ll}
\texttt{bool} & 8-bit\\
\texttt{byte}, \texttt{ubyte}, \texttt{char} & 8-bit\\
\texttt{short}, \texttt{ushort}, \texttt{wchar} & 16-bit\\
\texttt{int}, \texttt{uint}, \texttt{dchar}, \texttt{float} & 32-bit\\
\texttt{long}, \texttt{ulong}, \texttt{double} & 64-bit\\
\texttt{real} & $\ge$ 64-bit (generally 64-bit, but 80-bit on Intel x86 32-bit)
\end{tabular}
\texttt{char} represents UTF-8 characters, \texttt{wchar} represents UTF-16 characters, and \texttt{dchar} represents UTF-32 characters.
\subsection{Type conversion}
For integer types, automatic type conversion is only allowed if no precision is lost (e.g. \texttt{int} to \texttt{long}).
All conversion between floating point types are allowed (e.g. \texttt{double} to \texttt{float}).
Manual type conversion is achieved with the \texttt{cast} expression:
\begin{lstlisting}[style=D]
long a = 1;
int b = cast(int) a;
\end{lstlisting}
\subsection{Type properties}
All types have a property \texttt{.init} to which variables of that type are initialized, if they are not initialized explicitly.
For integer types, this is \texttt{0} and for floating point types it is \texttt{nan}.
Every type also has a \texttt{.stringof} property which yields its name as a string.
Integer types have some more properties:
\begin{tabular}{ll}
\texttt{.max} & The maximum value the type can hold\\
\texttt{.min} & The minimum value the type can hold
\end{tabular}
And so do floating point types:
\begin{tabular}{ll}
\texttt{.max} & The maximum value the type can hold\\
\texttt{.min\_normal} & The smallest representable normalized value that is not \texttt{0}\\
\texttt{.nan} & NaN value\\
\texttt{.infinity} & Infinity value\\
\texttt{.dig} & number of decimal digits of precisions\\
\texttt{.mant\_dig} & number of bits in mantissa\\
\dots
\end{tabular}
\subsection{Indexing}
For indexing, usually the alias type \texttt{size\_t} is used, which is large enough to represent an offset into all addressable memory.
\section{Variable declarations}
Variables are declared by writing the type followed by the variable name:
\begin{lstlisting}[style=D]
int myVar;
\end{lstlisting}
They can also be explicitly initialized:
\begin{lstlisting}[style=D]
int myVar = 42;
\end{lstlisting}
It is also possible to declare several variables at once:
\begin{lstlisting}[style=D]
int myVar, someOtherVar;
\end{lstlisting}
D has automatic type deduction, so when explicitly initializing a variable, it is not necessary to mention the type.
Instead we can use the \texttt{auto} keyword:
\begin{lstlisting}[style=D]
auto myVar = 42;
\end{lstlisting}
Here is a combination of the above notations:
\begin{lstlisting}[style=D]
auto myInt = 42, myFloat = 4.2f;
\end{lstlisting}
\section{Functions}
The basic syntax for functions is very similar to C:
\begin{lstlisting}[style=D]
int add(int lhs, int rhs) {
return lhs + rhs;
}
\end{lstlisting}
\subsection{Return type deduction}
A functions return type can be defined to be \texttt{auto}.
In this case, the return type will be infered.
Multiple return statements are possible, but must return compatible types.
\begin{lstlisting}[style=D]
auto add(int lhs, int rhs) { // returns `int`
return lhs + rhs;
}
auto lessOrEqual(int lhs, int rhs) { // returns `double`
if (lhs <= rhs)
return 0;
else
return 1.0;
}
\end{lstlisting}
\subsection{Default arguments}
Those also work the same as in C and other languages:
\begin{lstlisting}[style=D]
void plot(string msg, string color = "red") {
/* ... */
}
plot("D rocks");
plot("D rocks", "blue");
\end{lstlisting}
\subsection{Local functions}
It is possible to define functions locally (even inside other functions).
Those functions are not visible outside their parents scope.
\begin{lstlisting}[style=D]
void fun() {
int local = 10;
int fun_secret() {
local++; // that's legal
}
/* ... */
}
static assert(!__traits(compiles, fun_secret())); // fun_secret is not visible here
\end{lstlisting}
\section{Control flow}
\subsection{if\ldots{}else}
Very similar to how it is defined in other languages:
\begin{lstlisting}[style=D]
if (a == 5) {
writeln("Condition is met");
} else if (a > 10) {
writeln("Another condition is met");
} else {
writeln("Nothing is met!");
}
\end{lstlisting}
\subsection{switch\ldots{}case}
Also very similar to how it is defined in other languages, but for it works for integer types, bools and strings (which will be covered later).
\begin{lstlisting}[style=D]
string myString;
/* ... */
switch(myString) {
case "foo":
writeln("Cool, myString was \"foo\"");
break;
default:
writeln("Meh, myString was something boring");
break;
}
\end{lstlisting}
For integer types, it is also possible to define ranges:
\begin{lstlisting}[style=D]
int c = 5;
switch(c) {
case 0: .. case 9:
writeln(c, " is within 0-9");
break; // necessary!
case 10:
writeln("A Ten!");
break;
default: // if nothing else matches
writeln("Nothing");
break;
}
\end{lstlisting}
\subsection{Loops}
\texttt{while}-, \texttt{do\ldots{}while}- and classical \texttt{for}-loops all work the same as in C++/Java etc.
\subsubsection{Breaking out of outer loops}
As usual, you can break out of a loop immediately by using the \texttt{break} keyword. Additionally, you can also break out of outer loops by using labels:
\begin{lstlisting}[style=D]
outer: for (int i = 0; i < 10; ++i) {
for (int j = 0; j < 5; ++j) {
/*...*/
break outer; // breaks out of the outer loop
}
}
\end{lstlisting}
\end{document}