aboutsummaryrefslogtreecommitdiffstats
path: root/docs
diff options
context:
space:
mode:
Diffstat (limited to 'docs')
-rw-r--r--docs/contracts.rst6
-rw-r--r--docs/frequently-asked-questions.rst9
-rw-r--r--docs/miscellaneous.rst2
-rw-r--r--docs/security-considerations.rst3
-rw-r--r--docs/types.rst31
5 files changed, 10 insertions, 41 deletions
diff --git a/docs/contracts.rst b/docs/contracts.rst
index 86cdb3c4..56d651ee 100644
--- a/docs/contracts.rst
+++ b/docs/contracts.rst
@@ -1328,9 +1328,9 @@ custom types without the overhead of external function calls:
using BigInt for BigInt.bigint;
function f() public pure {
- var x = BigInt.fromUint(7);
- var y = BigInt.fromUint(uint(-1));
- var z = x.add(y);
+ BigInt.bigint memory x = BigInt.fromUint(7);
+ BigInt.bigint memory y = BigInt.fromUint(uint(-1));
+ BigInt.bigint memory z = x.add(y);
}
}
diff --git a/docs/frequently-asked-questions.rst b/docs/frequently-asked-questions.rst
index bb00441c..0d6fa033 100644
--- a/docs/frequently-asked-questions.rst
+++ b/docs/frequently-asked-questions.rst
@@ -136,14 +136,9 @@ See `struct_and_for_loop_tester.sol <https://github.com/fivedogit/solidity-baby-
How do for loops work?
======================
-Very similar to JavaScript. There is one point to watch out for, though:
+Very similar to JavaScript. Such as the following example:
-If you use ``for (var i = 0; i < a.length; i ++) { a[i] = i; }``, then
-the type of ``i`` will be inferred only from ``0``, whose type is ``uint8``.
-This means that if ``a`` has more than ``255`` elements, your loop will
-not terminate because ``i`` can only hold values up to ``255``.
-
-Better use ``for (uint i = 0; i < a.length...``
+``for (uint i = 0; i < a.length; i ++) { a[i] = i; }``
See `struct_and_for_loop_tester.sol <https://github.com/fivedogit/solidity-baby-steps/blob/master/contracts/65_struct_and_for_loop_tester.sol>`_.
diff --git a/docs/miscellaneous.rst b/docs/miscellaneous.rst
index 30ece7e1..d324b77a 100644
--- a/docs/miscellaneous.rst
+++ b/docs/miscellaneous.rst
@@ -157,7 +157,7 @@ These steps are applied to each basic block and the newly generated code is used
::
- var x = 7;
+ uint x = 7;
data[7] = 9;
if (data[x] != x + 2)
return 2;
diff --git a/docs/security-considerations.rst b/docs/security-considerations.rst
index c8d8c30b..afdecb98 100644
--- a/docs/security-considerations.rst
+++ b/docs/security-considerations.rst
@@ -103,7 +103,7 @@ outlined further below:
mapping(address => uint) shares;
/// Withdraw your share.
function withdraw() public {
- var share = shares[msg.sender];
+ uint share = shares[msg.sender];
shares[msg.sender] = 0;
msg.sender.transfer(share);
}
@@ -224,7 +224,6 @@ If your wallet had checked ``msg.sender`` for authorization, it would get the ad
Minor Details
=============
-- In ``for (var i = 0; i < arrayName.length; i++) { ... }``, the type of ``i`` will be ``uint8``, because this is the smallest type that is required to hold the value ``0``. If the array has more than 255 elements, the loop will not terminate.
- Types that do not occupy the full 32 bytes might contain "dirty higher order bits".
This is especially important if you access ``msg.data`` - it poses a malleability risk:
You can craft transactions that call a function ``f(uint8 x)`` with a raw byte argument
diff --git a/docs/types.rst b/docs/types.rst
index 528807d9..e1f8e6dd 100644
--- a/docs/types.rst
+++ b/docs/types.rst
@@ -7,10 +7,8 @@ Types
*****
Solidity is a statically typed language, which means that the type of each
-variable (state and local) needs to be specified (or at least known -
-see :ref:`type-deduction` below) at
-compile-time. Solidity provides several elementary types which can be combined
-to form complex types.
+variable (state and local) needs to be specified.
+Solidity provides several elementary types which can be combined to form complex types.
In addition, types can interact with each other in expressions containing
operators. For a quick reference of the various operators, see :ref:`order`.
@@ -548,7 +546,7 @@ memory-stored reference type do not create a copy.
// the data location of memoryArray is memory
function f(uint[] memoryArray) public {
x = memoryArray; // works, copies the whole array to storage
- var y = x; // works, assigns a pointer, data location of y is storage
+ uint[] storage y = x; // works, assigns a pointer, data location of y is storage
y[7]; // fine, returns the 8th element
y.length = 2; // fine, modifies x through y
delete x; // fine, clears the array, also modifies y
@@ -986,26 +984,3 @@ converted to a matching size. This makes alignment and padding explicit::
bytes32(uint256(x)); // pad on the left
bytes32(bytes2(x)); // pad on the right
-.. index:: ! type;deduction, ! var
-
-.. _type-deduction:
-
-Type Deduction
-==============
-
-For convenience, it is not always necessary to explicitly specify the type of a
-variable, the compiler automatically infers it from the type of the first
-expression that is assigned to the variable::
-
- uint24 x = 0x123;
- var y = x;
-
-Here, the type of ``y`` will be ``uint24``. Using ``var`` is not possible for function
-parameters or return parameters.
-
-.. warning::
- The type is only deduced from the first assignment, so
- the loop in the following snippet is infinite, as ``i`` will have the type
- ``uint8`` and the highest value of this type is smaller than ``2000``.
- ``for (var i = 0; i < 2000; i++) { ... }``
-