Tutorial

Question 1

which are pairs and mpairs

Answer 1

it’s a iterator which provides the element and an index number (immutable and mutable respectively)

Question 2

items and mitems

Answer 2

it’s a iterator which provides immutable and mutable elements respectively

Question 3

Control flow statements scope

Answer 3

is not accessible from outside, is a new scope

Question 4

what is block?

Answer 4

The block statement can be used to open a new block explicitly

Question 5

A block can be left prematurely with a

Answer 5

break statement

Question 6

what’s the purpouse Continue statement

Answer 6

Like in many other programming languages, a continue statement starts the next iteration immediately

Question 7

The when statement is almost identical to the if statement, but with these differences:

Answer 7

Each condition must be a constant expression since it is evaluated by the compiler.
The statements within a branch do not open a new scope.
The compiler checks the semantics and produces code only for the statements that belong to the first condition that evaluates to true.

Question 8

What is the utility of when statement

Answer 8

The when statement is useful for writing platform specific code, similar to the #ifdef construct in the C programming language.

Question 9

How to define a function

Answer 9

the concept of a procedure is needed. 
proc name(arg: type): typeOfReturn =

Question 10

whait is the Result variable

Answer 10

A procedure that returns a value has an implicit result variable declared that represents the return value.
A return statement with no expression is a shorthand for return result.
The result value is always returned automatically at the end of a procedure if there is no return statement at the exit.

Question 11

How to assign params by reference

Answer 11

a var parameter can be used
proc divmod(a, b: int; res, remainder: var int) =
  res = a div b        # integer division
  remainder = a mod b  # integer modulo operation

Question 12

What is the discard statement on the procedures definition

Answer 12

To call a procedure that returns a value just for its side effects and ignoring its return value, a discard statement must be used.
The return value can be ignored implicitly if the called proc/iterator has been declared with the discardable pragma

Question 13

What is the {.discardable.}

Answer 13

The return value can be ignored implicitly if the called proc/iterator has been declared with the discardable pragma

Question 14

How to define a new operator

Answer 14

enclose the operator in backticks “``”:

For example
proc $ (x: myDataType): string = …
# now the $ operator also works with myDataType, overloading resolution

Question 15

How to do a Forward declarations

Answer 15

The syntax for such a forward declaration is simple: just omit the = and the procedure’s body.

Question 16

Iterators look very similar to procedures, but there are several important differences

Answer 16

Iterators can only be called from ‘for’ loops.
Iterators cannot contain a return statement (and procs cannot contain a yield statement).
Iterators have no implicit result variable.
Iterators do not support recursion.
Iterators cannot be forward declared, because the compiler must be able to inline an iterator. (This restriction will be gone in a future version of the compiler.)

Question 17

what is the built-in $

Answer 17

the built-in $ (stringify) operator turns any basic type into a string, which you can then print to the console using the echo proc.

Question 18

what is a enum and its features

Answer 18

A variable of an enumeration type can only be assigned one of the enumeration’s specified values.
These values are a set of ordered symbols.
Each symbol is mapped to an integer value internally. The first symbol is represented at runtime by 0, the second by 1 and so on.

Question 19

what is the ‘type’ statement

Answer 19

the statetement to define a advanced type. As the var statement.

Question 20

how can you to convert any enumeration value to its name

Answer 20

with the $ operator

Question 21

how can you can convert any enumeration it to its underlying integer value.

Answer 21

with the ‘orc’ proc

Question 22

The symbols of enum types can be assigned an explicit ordinal value. How to do that.

Answer 22

he ordinal values must be in ascending order.

A symbol whose ordinal value is not explicitly given is assigned the value of the previous symbol + 1.

Question 23

what are the Ordinal types

Answer 23

Enumerations without holes, integer types, char and bool (and subranges)

Question 24

what are the Ordinal types features

Answer 24

ord(x) returns the integer value that is used to represent x’s value
inc(x) increments x by one
inc(x, n) increments x by n; n is an integer
dec(x) decrements x by one
dec(x, n) decrements x by n; n is an integer
succ(x) returns the successor of x
succ(x, n) returns the n’th successor of x
pred(x) returns the predecessor of x
pred(x, n) returns the n’th predecessor of x

Question 25

what are Subranges

Answer 25

A subrange type is a range of values from an integer or enumeration type (the base type). Example:

type
MySubrange = range[0..5]

Question 26

For what is the Natural type made for?

Answer 26

Other programming languages may suggest the use of unsigned integers for natural numbers. This is often unwise: you don’t want unsigned arithmetic (which wraps around) just because the numbers cannot be negative. Nim’s Natural type helps to avoid this common programming error.

Question 27

what are Sets

Answer 27

The set type models the mathematical notion of a set.

Sets can be constructed via the set constructor: {} is the empty set.

Question 28

Sets features

Answer 28

A + B union of two sets
A * B intersection of two sets
A - B difference of two sets (A without B’s elements)
A == B set equality
A <= B subset relation (A is subset of B or equal to B)
A < B strong subset relation (A is a real subset of B)
e in A set membership (A contains element e)
e notin A A does not contain element e
contains(A, e) A contains element e
card(A) the cardinality of A (number of elements in A)
incl(A, elem) same as A = A + {elem}
excl(A, elem) same as A = A - {elem}

Question 29

what are Sequences

Answer 29

Sequences are similar to arrays but of dynamic length which may change during runtime (like strings). Since sequences are resizable they are always allocated on the heap and garbage collected.

Question 30

what are Arrays

Answer 30

An array is a simple fixed length container. Each element in an array has the same type. The array’s index type can be any ordinal type.

Question 31

How to create a Sequence

Answer 31

x: seq[int]

x = @[1, 2, 3, 4, 5, 6]

Question 32

What are Open arrays

Answer 32

Note: Openarrays can only be used for parameters.
Often fixed size arrays turn out to be too inflexible; procedures should be able to deal with arrays of different sizes. The openarray type allows this.

Question 33

what are Varargs

Answer 33

A varargs parameter is like an openarray parameter. However, it is also a means to implement passing a variable number of arguments to a procedure. The compiler converts the list of arguments to an array automatically
This transformation is only done if the varargs parameter is the last parameter in the procedure header. It is also possible to perform type conversions in this context:

Question 34

what are Slices

Answer 34

Slices look similar to subranges types in syntax but are used in a different context. A slice is just an object of type Slice which contains two bounds, a and b.

Question 35

what are Tuples

Answer 35

A tuple type defines various named fields and an order of the fields. 
The constructor () can be used to construct tuples. 
The order of the fields in the constructor must match the order in the tuple's definition.

Question 36

what are Reference and pointer types

Answer 36

References (similar to pointers in other programming languages) are a way to introduce many-to-one relationships.
This means different references can point to and modify the same location in memory.

Question 37

what are Untraced references

Answer 37

Untraced references are also called pointers. Thus untraced references are unsafe. However for certain low-level operations (e.g., accessing the hardware), untraced references are necessary.
untraced references point to manually allocated objects or to objects elsewhere in memory.
untraced references are declared with the ptr keyword.

Question 38

what are Traced references

Answer 38

Traced references point to objects in a garbage collected heap,
Traced references are declared with the ref keyword;

Question 39

how to construct a Tuple

Answer 39

person = (name: “Peter”, age: 30)

var teacher: tuple[name: string, age: int] = (“Mark”, 42)

Question 40

how to import a module

Answer 40

import
import … except
from