cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

minor punctuation, typo and clarity changes

Browse Source
This commit is contained in:
greggdourgarian 2017-05-03 12:24:00 -05:00
parent 34b28ed760
commit d13a1f4f7b
1 changed files with 27 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
docs/contracts.rst
View File

@ -20,7 +20,7 @@ Contracts can be created "from outside" or from Solidity contracts.
When a contract is created, its constructor (a function with the same When a contract is created, its constructor (a function with the same
name as the contract) is executed once. name as the contract) is executed once.
A constructor is optional. Only one constructor is allowed and this means A constructor is optional. Only one constructor is allowed, and this means
overloading is not supported. overloading is not supported.
From ``web3.js``, i.e. the JavaScript From ``web3.js``, i.e. the JavaScript
@ -273,7 +273,7 @@ be done at declaration.
The getter functions have external visibility. If the The getter functions have external visibility. If the
symbol is accessed internally (i.e. without ``this.``), symbol is accessed internally (i.e. without ``this.``),
it is evaluated as a state variable and if it is accessed externally it is evaluated as a state variable. If it is accessed externally
(i.e. with ``this.``), it is evaluated as a function. (i.e. with ``this.``), it is evaluated as a function.
:: ::
@ -321,8 +321,8 @@ is no good way to provide the key for the mapping.
Function Modifiers Function Modifiers
****************** ******************
Modifiers can be used to easily change the behaviour of functions, for example Modifiers can be used to easily change the behaviour of functions. For example,
to automatically check a condition prior to executing the function. They are they can automatically check a condition prior to executing the function. Modifiers are
inheritable properties of contracts and may be overridden by derived contracts. inheritable properties of contracts and may be overridden by derived contracts.
:: ::
@ -405,8 +405,8 @@ inheritable properties of contracts and may be overridden by derived contracts.
} }
} }
Multiple modifiers can be applied to a function by specifying them in a Multiple modifiers are applied to a function by specifying them in a
whitespace-separated list and will be evaluated in order. whitespace-separated list and are evaluated in the order presented.
.. warning:: .. warning::
In an earlier version of Solidity, ``return`` statements in functions In an earlier version of Solidity, ``return`` statements in functions
@ -441,7 +441,7 @@ The reason behind allowing side-effects on the memory allocator is that it
should be possible to construct complex objects like e.g. lookup-tables. should be possible to construct complex objects like e.g. lookup-tables.
This feature is not yet fully usable. This feature is not yet fully usable.
The compiler does not reserve a storage slot for these variables and every occurrence is The compiler does not reserve a storage slot for these variables, and every occurrence is
replaced by the respective constant expression (which might be computed to a single value by the optimizer). replaced by the respective constant expression (which might be computed to a single value by the optimizer).
Not all types for constants are implemented at this time. The only supported types are Not all types for constants are implemented at this time. The only supported types are
@ -462,7 +462,7 @@ value types and strings.
Constant Functions Constant Functions
****************** ******************
Functions can be declared constant. These functions promise not to modify the state. Functions can be declared constant in which case they promise not to modify the state.
:: ::
@ -491,7 +491,7 @@ Fallback Function
A contract can have exactly one unnamed function. This function cannot have A contract can have exactly one unnamed function. This function cannot have
arguments and cannot return anything. arguments and cannot return anything.
It is executed on a call to the contract if none of the other It is executed on a call to the contract if none of the other
functions matches the given function identifier (or if no data was supplied at functions match the given function identifier (or if no data was supplied at
all). all).
Furthermore, this function is executed whenever the contract receives plain Furthermore, this function is executed whenever the contract receives plain
@ -567,13 +567,12 @@ the contract and will be incorporated into the blockchain
and stay there as long as a block is accessible (forever as of and stay there as long as a block is accessible (forever as of
Frontier and Homestead, but this might change with Serenity). Log and Frontier and Homestead, but this might change with Serenity). Log and
event data is not accessible from within contracts (not even from event data is not accessible from within contracts (not even from
the contract that created a log). the contract that created them).
SPV proofs for logs are possible, so if an external entity supplies SPV proofs for logs are possible, so if an external entity supplies
a contract with such a proof, it can check that the log actually a contract with such a proof, it can check that the log actually
exists inside the blockchain (but be aware of the fact that exists inside the blockchain. But be aware that block headers have to be supplied because
ultimately, also the block headers have to be supplied because the contract can only see the last 256 block hashes.
the contract can only see the last 256 block hashes).
Up to three parameters can Up to three parameters can
receive the attribute ``indexed`` which will cause the respective arguments receive the attribute ``indexed`` which will cause the respective arguments
@ -590,7 +589,7 @@ not possible to filter for specific anonymous events by name.
All non-indexed arguments will be stored in the data part of the log. All non-indexed arguments will be stored in the data part of the log.
.. note:: .. note::
Indexed arguments will not be stored themselves, you can only Indexed arguments will not be stored themselves. You can only
search for the values, but it is impossible to retrieve the search for the values, but it is impossible to retrieve the
values themselves. values themselves.
@ -679,9 +678,9 @@ Solidity supports multiple inheritance by copying code including polymorphism.
All function calls are virtual, which means that the most derived function All function calls are virtual, which means that the most derived function
is called, except when the contract name is explicitly given. is called, except when the contract name is explicitly given.
Even if a contract inherits from multiple other contracts, only a single When a contract inherits from multiple contracts, only a single
contract is created on the blockchain, the code from the base contracts contract is created on the blockchain, and the code from all the base contracts
is always copied into the final contract. is copied into the created contract.
The general inheritance system is very similar to The general inheritance system is very similar to
`Python's <https://docs.python.org/3/tutorial/classes.html#inheritance>`_, `Python's <https://docs.python.org/3/tutorial/classes.html#inheritance>`_,
@ -818,7 +817,7 @@ derived override, but this function will bypass
} }
If ``Base1`` calls a function of ``super``, it does not simply If ``Base1`` calls a function of ``super``, it does not simply
call this function on one of its base contracts, it rather call this function on one of its base contracts. Rather, it
calls this function on the next base contract in the final calls this function on the next base contract in the final
inheritance graph, so it will call ``Base2.kill()`` (note that inheritance graph, so it will call ``Base2.kill()`` (note that
the final inheritance sequence is -- starting with the most the final inheritance sequence is -- starting with the most
@ -834,9 +833,9 @@ Arguments for Base Constructors
=============================== ===============================
Derived contracts need to provide all arguments needed for Derived contracts need to provide all arguments needed for
the base constructors. This can be done at two places:: the base constructors. This can be done in two ways::
pragma solidity ^0.4.0; pragma solidity ^0.4.0;s
contract Base { contract Base {
uint x; uint x;
@ -849,7 +848,7 @@ the base constructors. This can be done at two places::
} }
} }
Either directly in the inheritance list (``is Base(7)``) or in One way is directly in the inheritance list (``is Base(7)``). The other is in
the way a modifier would be invoked as part of the header of the way a modifier would be invoked as part of the header of
the derived constructor (``Base(_y * _y)``). The first way to the derived constructor (``Base(_y * _y)``). The first way to
do it is more convenient if the constructor argument is a do it is more convenient if the constructor argument is a
@ -865,7 +864,7 @@ Multiple Inheritance and Linearization
====================================== ======================================
Languages that allow multiple inheritance have to deal with Languages that allow multiple inheritance have to deal with
several problems, one of them being the `Diamond Problem <https://en.wikipedia.org/wiki/Multiple_inheritance#The_diamond_problem>`_. several problems. One is the `Diamond Problem <https://en.wikipedia.org/wiki/Multiple_inheritance#The_diamond_problem>`_.
Solidity follows the path of Python and uses "`C3 Linearization <https://en.wikipedia.org/wiki/C3_linearization>`_" Solidity follows the path of Python and uses "`C3 Linearization <https://en.wikipedia.org/wiki/C3_linearization>`_"
to force a specific order in the DAG of base classes. This to force a specific order in the DAG of base classes. This
results in the desirable property of monotonicity but results in the desirable property of monotonicity but
@ -937,7 +936,7 @@ Interfaces are similar to abstract contracts, but they cannot have any functions
Some of these restrictions might be lifted in the future. Some of these restrictions might be lifted in the future.
Interfaces are basically limited to what the Contract ABI can represent and the conversion between the ABI and Interfaces are basically limited to what the Contract ABI can represent, and the conversion between the ABI and
an Interface should be possible without any information loss. an Interface should be possible without any information loss.
Interfaces are denoted by their own keyword: Interfaces are denoted by their own keyword:
@ -976,9 +975,9 @@ contracts (``L.f()`` if ``L`` is the name of the library). Furthermore,
if the library were a base contract. Of course, calls to internal functions if the library were a base contract. Of course, calls to internal functions
use the internal calling convention, which means that all internal types use the internal calling convention, which means that all internal types
can be passed and memory types will be passed by reference and not copied. can be passed and memory types will be passed by reference and not copied.
In order to realise this in the EVM, code of internal library functions To realize this in the EVM, code of internal library functions
(and all functions called from therein) will be pulled into the calling and all functions called from therein will be pulled into the calling
contract and a regular ``JUMP`` call will be used instead of a ``DELEGATECALL``. contract, and a regular ``JUMP`` call will be used instead of a ``DELEGATECALL``.
.. index:: using for, set .. index:: using for, set
@ -1041,8 +1040,8 @@ more advanced example to implement a set).
Of course, you do not have to follow this way to use Of course, you do not have to follow this way to use
libraries - they can also be used without defining struct libraries - they can also be used without defining struct
data types, functions also work without any storage data types. Functions also work without any storage
reference parameters, can have multiple storage reference reference parameters, and they can have multiple storage reference
parameters and in any position. parameters and in any position.
The calls to ``Set.contains``, ``Set.insert`` and ``Set.remove`` The calls to ``Set.contains``, ``Set.insert`` and ``Set.remove``