Documentation.

Changelog.md

@@ -1,6 +1,7 @@
 ### 0.7.1 (unreleased)
 
 Language Features:
+ * Allow function definitions outside of contracts, behaving much like internal library functions.
 
 
 Compiler Features:

docs/Solidity.g4

@@ -8,7 +8,7 @@
 grammar Solidity;
 
 sourceUnit
-  : (pragmaDirective | importDirective | structDefinition | enumDefinition | contractDefinition)* EOF ;
+  : (pragmaDirective | importDirective | structDefinition | enumDefinition | functionDefinition | contractDefinition)* EOF ;
 
 pragmaDirective
   : 'pragma' pragmaName ( ~';' )* ';' ;

docs/contracts/function-modifiers.rst

@@ -18,7 +18,7 @@ if they are marked ``virtual``. For details, please see
 ::
 
     // SPDX-License-Identifier: GPL-3.0
-    pragma solidity >0.6.99 <0.8.0;
+    pragma solidity >0.7.0 <0.8.0;
 
     contract owned {
         constructor() { owner = msg.sender; }

docs/contracts/functions.rst

@@ -6,6 +6,34 @@
 Functions
 *********
 
+Functions can be defined inside and outside of contracts.
+
+Functions outside of a contract, also called "free functions", always have implicit ``internal``
+:ref:`visibility<visibility-and-getters>`. Their code is included in all contracts
+that call them, similar to internal library functions.
+
+::
+
+    // SPDX-License-Identifier: GPL-3.0
+    pragma solidity >0.7.0 <0.8.0;
+
+    function sum(uint[] memory _arr) pure returns (uint s) {
+        for (uint i = 0; i < _arr.length; i++)
+            s += _arr[i];
+    }
+
+    contract ArrayExample {
+        bool found;
+        function f(uint[] memory _arr) public {
+            // This calls the free function internally.
+            // The compiler will add its code to the contract.
+            uint s = sum(_arr);
+            require(s >= 10);
+            found = true;
+        }
+    }
+
+
 .. _function-parameters-return-variables:
 
 Function Parameters and Return Variables

docs/layout-of-source-files.rst

@@ -5,7 +5,7 @@ Layout of a Solidity Source File
 Source files can contain an arbitrary number of
 :ref:`contract definitions<contract_structure>`, import_ directives,
 :ref:`pragma directives<pragma>` and
-:ref:`struct<structs>` and :ref:`enum<enums>` definitions.
+:ref:`struct<structs>`, :ref:`enum<enums>` and :ref:`function<functions>` definitions.
 
 .. index:: ! license, spdx
 

docs/structure-of-a-contract.rst

@@ -43,12 +43,14 @@ visibility.
 Functions
 =========
 
-Functions are the executable units of code within a contract.
+Functions are the executable units of code. Functions are usually
+defined inside a contract, but they can also be defined outside of
+contracts.
 
 ::
 
     // SPDX-License-Identifier: GPL-3.0
-    pragma solidity >=0.4.0 <0.8.0;
+    pragma solidity >0.7.0 <0.8.0;
 
     contract SimpleAuction {
         function bid() public payable { // Function
@@ -56,6 +58,11 @@ Functions are the executable units of code within a contract.
         }
     }
 
+    // Helper function defined outside of a contract
+    function helper(uint x) pure returns (uint) {
+        return x * 2;
+    }
+
 :ref:`function-calls` can happen internally or externally
 and have different levels of :ref:`visibility<visibility-and-getters>`
 towards other contracts. :ref:`Functions<functions>` accept :ref:`parameters and return variables<function-parameters-return-variables>` to pass parameters