Solidity

https://docs.soliditylang.org/en/v0.8.30/
Admin
Solidity is an object-oriented, high-level language for implementing smart contracts that govern...
Tokens:165,756
Snippets:1,447
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Solidity CLI Example Command

Source: https://docs.soliditylang.org/en/v0.8.30/path-resolution.html

An example command demonstrating the use of --base-path and --include-path with the Solidity compiler. This highlights how paths are processed and the potential for ambiguity if source files exist in multiple specified locations.

```bash
solc /project/contract.sol --base-path /project --include-path /lib
```

--------------------------------

### Install Solidity Dependencies (PowerShell)

Source: https://docs.soliditylang.org/en/v0.8.30/installing-solidity.html

This PowerShell script automates the installation of required external dependencies like 'boost' and 'cmake' for building Solidity. It places them in the 'deps' subdirectory.

```powershell
scripts\install_deps.ps1
```

--------------------------------

### Example User Documentation JSON

Source: https://docs.soliditylang.org/en/v0.8.30/natspec-format.html

Provides an example of the JSON structure produced by the compiler for user-facing documentation.

```json
{
  "version" : 1,
  "kind" : "user",
  "methods" :
  {
    "age(uint256)" :
    {
      "notice" : "Calculate tree age in years, rounded up, for live trees"
    },
    "leaves()" :
    {
        "notice" : "Returns the amount of leaves the tree has."
    }
  },
  "notice" : "You can use this contract for only the most basic simulation"
}
```

--------------------------------

### Solidity Mapping Example: Basic Usage

Source: https://docs.soliditylang.org/en/v0.8.30/types.html

Demonstrates a basic mapping in Solidity where an address is mapped to a uint. It shows how to declare a public mapping, update its values, and access them via a generated getter function. This example highlights the fundamental structure and interaction with mappings.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract MappingExample {
    mapping(address => uint) public balances;

    function update(uint newBalance) public {
        balances[msg.sender] = newBalance;
    }
}

contract MappingUser {
    function f() public returns (uint) {
        MappingExample m = new MappingExample();
        m.update(100);
        return m.balances(address(this));
    }
}

```

--------------------------------

### Example Developer Documentation JSON

Source: https://docs.soliditylang.org/en/v0.8.30/natspec-format.html

Provides an example of the JSON structure produced by the compiler for developer-facing documentation, including parameter and return value details.

```json
{
  "version" : 1,
  "kind" : "dev",
  "author" : "Larry A. Gardner",
  "details" : "All function calls are currently implemented without side effects",
  "custom:experimental" : "This is an experimental contract.",
  "methods" :
  {
    "age(uint256)" :
    {
      "details" : "The Alexandr N. Tetearing algorithm could increase precision",
      "params" :
      {
        "rings" : "The number of rings from dendrochronological sample"
      },
      "returns" : {
        "_0" : "Age in years, rounded up for partial years",
        "_1" : "Name of the tree"
      }
    },
    "leaves()" :
    {
        "details" : "Returns only a fixed number."
    }
  },
  "title" : "A simulator for trees"
}
```

--------------------------------

### Build Solidity with CMake (Linux/macOS)

Source: https://docs.soliditylang.org/en/v0.8.30/installing-solidity.html

Standard build process for Solidity on Linux, macOS, and other Unix-like systems using CMake and Make. Assumes external dependencies are already installed.

```bash
mkdir build
cd build
cmake .. && make
```

--------------------------------

### Solidity delete Keyword Example

Source: https://docs.soliditylang.org/en/v0.8.30/types.html

Provides an example of the 'delete' keyword in Solidity, showing its application to reset variables to their default initial values. It demonstrates how 'delete' affects integers, arrays, and structs, and notes its ineffectiveness on mappings for entire variables but its ability to delete individual key-value pairs.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;

contract DeleteExample {
    uint data;
    uint[] dataArray;

    function f() public {
        uint x = data;
        delete x; // sets x to 0, does not affect data
        delete data; // sets data to 0, does not affect x
        uint[] storage y = dataArray;
        delete dataArray; // this sets dataArray.length to zero, but as uint[] is a complex object, also
        // y is affected which is an alias to the storage object
        // On the other hand: "delete y" is not valid, as assignments to local variables
        // referencing storage objects can only be made from existing storage objects.
        assert(y.length == 0);
    }
}
```

--------------------------------

### SMTChecker State Variable Analysis Example

Source: https://docs.soliditylang.org/en/v0.8.30/smtchecker.html

Demonstrates how the SMTChecker handles state variables of contract types. The example shows how external calls to contract A from contract B can lead to assertion failures due to the current encoding limitations.

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.8.0;

contract A {
    uint public x;
    address immutable public owner;
    constructor() {
        owner = msg.sender;
    }
    function setX(uint _x) public {
        require(msg.sender == owner);
        x = _x;
    }
}

contract B {
    A a;
    constructor() {
        a = new A();
        assert(a.x() == 0); // (1) should hold
    }
    function g() public view {
        assert(a.owner() == address(this)); // (2) should hold
        assert(a.x() == 0); // (3) should hold, but fails due to a false positive
    }
}
```

--------------------------------

### Solidity String and Bytes Concatenation Example

Source: https://docs.soliditylang.org/en/v0.8.30/types.html

Demonstrates the usage of `string.concat` and `bytes.concat` functions in Solidity. It shows how to concatenate strings and bytes, including literals and variables, and verifies the resulting lengths. This example highlights the conversion of different types to string or bytes before concatenation and the behavior of these functions with empty arguments.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.12;

contract C {
    string s = "Storage";
    function f(bytes calldata bc, string memory sm, bytes16 b) public view {
        string memory concatString = string.concat(s, string(bc), "Literal", sm);
        assert((bytes(s).length + bc.length + 7 + bytes(sm).length) == bytes(concatString).length);

        bytes memory concatBytes = bytes.concat(bytes(s), bc, bc[:2], "Literal", bytes(sm), b);
        assert((bytes(s).length + bc.length + 2 + 7 + bytes(sm).length + b.length) == concatBytes.length);
    }
}

```

--------------------------------

### Solidity Enum Definition and Usage

Source: https://docs.soliditylang.org/en/v0.8.30/types.html

Defines and demonstrates the usage of an enum type in Solidity. Enums create user-defined types with named integer values, starting from 0. They are explicitly convertible to integer types and have methods to get min/max values.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.8;

contract test {
    enum ActionChoices { GoLeft, GoRight, GoStraight, SitStill }
    ActionChoices choice;
    ActionChoices constant defaultChoice = ActionChoices.GoStraight;

    function setGoStraight() public {
        choice = ActionChoices.GoStraight;
    }

    // Since enum types are not part of the ABI, the signature of "getChoice"
    // will automatically be changed to "getChoice() returns (uint8)"
    // for all matters external to Solidity.
    function getChoice() public view returns (ActionChoices) {
        return choice;
    }

    function getDefaultChoice() public pure returns (uint) {
        return uint(defaultChoice);
    }

    function getLargestValue() public pure returns (ActionChoices) {
        return type(ActionChoices).max;
    }

    function getSmallestValue() public pure returns (ActionChoices) {
        return type(ActionChoices).min;
    }
}
```

--------------------------------

### Configure Solc with Base and Include Paths

Source: https://docs.soliditylang.org/en/v0.8.30/path-resolution.html

This example demonstrates how to use the Solidity compiler (solc) with --base-path and --include-path options. It specifies the current directory as the base path and 'node_modules/' as an include path, allowing the compiler to resolve imports from external libraries like OpenZeppelin.

```bash
solc contract.sol \
    --base-path . \
    --include-path node_modules/ \
    --include-path /usr/local/lib/node_modules/
```

--------------------------------

### Run Solidity Compiler with Docker

Source: https://docs.soliditylang.org/en/v0.8.30/installing-solidity.html

Demonstrates how to use the official Solidity Docker image to execute compiler commands. This includes running help commands, compiling local files by mounting volumes, and using the standard JSON interface for automated tooling.

```bash
docker run ethereum/solc:stable --help
```

```bash
docker run \
    --volume "/tmp/some/local/path/:/sources/" \
    ethereum/solc:stable \
        /sources/Contract.sol \
        --abi \
        --bin \
        --output-dir /sources/output/
```

```bash
docker run ethereum/solc:stable --standard-json < input.json > output.json
```

--------------------------------

### Configure Import Remapping via Command Line

Source: https://docs.soliditylang.org/en/v0.8.30/path-resolution.html

Demonstrates how to use the solc command line interface to remap import paths. This example shows mapping a project directory to a specific path and handling URL protocols.

```bash
solc /project/=/contracts /project/contract.sol
solc :https://github.com/ethereum/dapp-bin=/usr/local/dapp-bin contract.sol
```

--------------------------------

### Configure Solidity Compiler Import Remapping

Source: https://docs.soliditylang.org/en/v0.8.30/path-resolution.html

Demonstrates how to use the solc command-line interface to remap a GitHub-style import path to a local directory path.

```bash
solc github.com/ethereum/dapp-bin/=dapp-bin/ --base-path /project source.sol
```

--------------------------------

### Memory-Unsafe Assembly Example (Solidity)

Source: https://docs.soliditylang.org/en/v0.8.30/assembly.html

This example illustrates an inline assembly block that is not memory-safe. It uses `returndatasize()` which can exceed the 64-byte scratch space, violating the memory-safe assumptions required for compiler optimizations.

```Solidity
assembly {
  returndatacopy(0, 0, returndatasize())
  revert(0, returndatasize())
}
```

--------------------------------

### Yul: Motivation and Examples

Source: https://docs.soliditylang.org/en/v0.8.30/index.html

An introduction to Yul, an intermediate language for the Solidity compiler. It covers the motivation behind Yul, its high-level description, and provides simple and complete examples like the ERC20 implementation.

```Yul
object "my_contract" {
  code {
    // Yul code goes here
  }
}
```

--------------------------------

### Solidity Contract Creation using 'new'

Source: https://docs.soliditylang.org/en/v0.8.30/control-structures.html

Shows how to create new contract instances using the 'new' keyword in Solidity. It covers basic creation, creation with arguments, and creation with Ether transfer using the 'value' option. Contract creation failures throw an exception.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
contract D {
    uint public x;
    constructor(uint a) payable {
        x = a;
    }
}

contract C {
    D d = new D(4); // will be executed as part of C's constructor

    function createD(uint arg) public {
        D newD = new D(arg);
        newD.x();
    }

    function createAndEndowD(uint arg, uint amount) public payable {
        // Send ether along with the creation
        D newD = new D{value: amount}(arg);
        newD.x();
    }
}
```

--------------------------------

### Resolving Complex Relative Import Paths

Source: https://docs.soliditylang.org/en/v0.8.30/path-resolution.html

Examples of how the Solidity compiler normalizes complex relative paths containing multiple segments, dots, and slashes. These examples illustrate how path resolution behaves when navigating through nested directories.

```Solidity
import "./util/./util.sol";
import "./util//util.sol";
import "../util/../array/util.sol";
import "../.././../util.sol";
import "../../.././../util.sol";
```

--------------------------------

### Defining Custom Storage Layout with Inheritance in Solidity

Source: https://docs.soliditylang.org/en/v0.8.30/internals/layout_in_storage.html

This example demonstrates how to define state variables across multiple contracts and apply a custom storage base slot using the 'layout at' syntax. It illustrates how inheritance, structs, and arrays affect the final storage slot allocation.

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.29;

struct S {
    int32 x;
    bool y;
}

contract A {
    uint a;
    uint128 transient b;
    uint constant c = 10;
    uint immutable d = 12;
}

contract B {
    uint8[] e;
    mapping(uint => S) f;
    uint16 g;
    uint16 h;
    bytes16 transient i;
    S s;
    int8 k;
}

contract C is A, B layout at 42 {
    bytes21 l;
    uint8[10] m;
    bytes5[8] n;
    bytes5 o;
}
```

--------------------------------

### Install solcjs via npm

Source: https://docs.soliditylang.org/en/v0.8.30/installing-solidity.html

Installs the solcjs compiler globally using the Node.js package manager. This provides a portable way to access the Solidity compiler, though it has fewer features than the full C++ solc binary.

```bash
npm install --global solc
```

--------------------------------

### Build Solidity with CMake (Windows)

Source: https://docs.soliditylang.org/en/v0.8.30/installing-solidity.html

Instructions for configuring the Solidity build on Windows using CMake with the 'Visual Studio 16 2019' generator. Includes options for specifying Boost and MSVC runtime library.

```bash
mkdir build
cd build
cmake -G "Visual Studio 16 2019" .. -DBoost_ROOT="deps/boost" -DBoost_INCLUDE_DIR="deps/boost/include" -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded
cmake --build . --config Release
```

--------------------------------

### Solidity Overload Resolution Example

Source: https://docs.soliditylang.org/en/v0.8.30/contracts.html

Shows how Solidity resolves overloaded function calls based on argument matching and implicit type conversions. It highlights that return parameters are not considered during overload resolution and provides examples of ambiguous and unambiguous calls.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract A {
    function f(uint8 val) public pure returns (uint8 out) {
        out = val;
    }

    function f(uint256 val) public pure returns (uint256 out) {
        out = val;
    }
}

```

--------------------------------

### Solidity Function Visibility Specifiers Example

Source: https://docs.soliditylang.org/en/v0.8.30/cheatsheet.html

Demonstrates the usage of function visibility specifiers in Solidity. These specifiers control the accessibility of functions, affecting how they can be called internally or externally. The example shows a basic function structure where a specifier would be placed.

```Solidity
function myFunction() <visibility specifier> returns (bool) {
    return true;
}
```

--------------------------------

### Implementing a Set Library in Solidity

Source: https://docs.soliditylang.org/en/v0.8.30/contracts.html

This snippet demonstrates creating a library that manages a set of data using a struct and storage references. It shows how library functions can be called from a contract to manipulate state.

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.9.0;

struct Data {
    mapping(uint => bool) flags;
}

library Set {
    function insert(Data storage self, uint value) public returns (bool) {
        if (self.flags[value]) return false;
        self.flags[value] = true;
        return true;
    }

    function remove(Data storage self, uint value) public returns (bool) {
        if (!self.flags[value]) return false;
        self.flags[value] = false;
        return true;
    }

    function contains(Data storage self, uint value) public view returns (bool) {
        return self.flags[value];
    }
}

contract C {
    Data knownValues;
    function register(uint value) public {
        require(Set.insert(knownValues, value));
    }
}
```

--------------------------------

### Solidity Constant and Immutable Variables Example

Source: https://docs.soliditylang.org/en/v0.8.30/contracts.html

Demonstrates the declaration and usage of `constant` and `immutable` state variables in a Solidity contract. It shows how constants are assigned at compile-time and immutables at construction time, including examples of their usage within a constructor and a view function.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.21;

uint constant X = 32**22 + 8;

contract C {
    string constant TEXT = "abc";
    bytes32 constant MY_HASH = keccak256("abc");
    uint immutable decimals = 18;
    uint immutable maxBalance;
    address immutable owner = msg.sender;

    constructor(uint decimals_, address ref) {
        if (decimals_ != 0)
            // Immutables are only immutable when deployed.
            // At construction time they can be assigned to any number of times.
            decimals = decimals_;

        // Assignments to immutables can even access the environment.
        maxBalance = ref.balance;
    }

    function isBalanceTooHigh(address other) public view returns (bool) {
        return other.balance > maxBalance;
    }
}

```

--------------------------------

### Link Libraries via Command Line

Source: https://docs.soliditylang.org/en/v0.8.30/using-the-compiler.html

Demonstrates how to provide library addresses to the solc compiler using the --libraries flag. This replaces placeholders in the bytecode with the specified hexadecimal addresses.

```bash
solc --libraries "file.sol:Math=0x1234567890123456789012345678901234567890 file.sol:Heap=0xabCD567890123456789012345678901234567890"
```

--------------------------------

### Example Yul Object for Contract Deployment

Source: https://docs.soliditylang.org/en/v0.8.30/yul.html

An example demonstrating a Yul object structure for a contract, including constructor code, deployed runtime code, and embedded objects for other contracts. It showcases the use of datacopy, dataoffset, and datasize for accessing different sections and objects.

```Yul
// A contract consists of a single object with sub-objects representing
// the code to be deployed or other contracts it can create.
// The single "code" node is the executable code of the object.
// Every (other) named object or data item inside the current object
// are in scope.
object "Contract1" {
    // This is the constructor code of the contract.
    code {
        function allocate(size) -> ptr {
            ptr := mload(0x40)
            // Note that Solidity generated IR code reserves memory offset ``0x60`` as well, but a pure Yul object is free to use memory as it chooses.
            if iszero(ptr) { ptr := 0x60 }
            mstore(0x40, add(ptr, size))
        }

        // first create "Contract2"
        let size := datasize("Contract2")
        let offset := allocate(size)
        // This will turn into codecopy for EVM
        datacopy(offset, dataoffset("Contract2"), size)
        // constructor parameter is a single number 0x1234
        mstore(add(offset, size), 0x1234)
        pop(create(0, offset, add(size, 32)))

        // now return the runtime object (the currently
        // executing code is the constructor code)
        size := datasize("Contract1_deployed")
        offset := allocate(size)
        // This will turn into a codecopy for EVM
        datacopy(offset, dataoffset("Contract1_deployed"), size)
        return(offset, size)
    }

    data "Table2" hex"4123"

    object "Contract1_deployed" {
        code {
            function allocate(size) -> ptr {
                ptr := mload(0x40)
                // Note that Solidity generated IR code reserves memory offset ``0x60`` as well, but a pure Yul object is free to use memory as it chooses.
                if iszero(ptr) { ptr := 0x60 }
                mstore(0x40, add(ptr, size))
            }

            // runtime code

            mstore(0, "Hello, World!")
            return(0, 0x20)
        }
    }

    // Embedded object. Use case is that the outside is a factory contract,
    // and Contract2 is the code to be created by the factory
    object "Contract2" {
        code {
            // code here ...
        }

        object "Contract2_deployed" {
            code {
                // code here ...
            }
        }

        data "Table1" hex"4123"
    }
}
```

--------------------------------

### Initialize Dynamically-Sized Memory Arrays in Solidity

Source: https://docs.soliditylang.org/en/v0.8.30/types.html

Illustrates the correct way to initialize dynamically-sized memory arrays by first allocating the required size using 'new' and then assigning individual elements. Direct assignment from fixed-size array literals to dynamically-sized arrays is not supported due to ABI complexities.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract C {
    function f() public pure {
        uint[] memory x = new uint[](3);
        x[0] = 1;
        x[1] = 3;
        x[2] = 4;
    }
}
```

--------------------------------

### Context-Specific Import Remapping

Source: https://docs.soliditylang.org/en/v0.8.30/path-resolution.html

Illustrates how to apply different remappings for different modules using context prefixes in the solc command.

```bash
solc module1:github.com/ethereum/dapp-bin/=dapp-bin/ \
     module2:github.com/ethereum/dapp-bin/=dapp-bin_old/ \
     --base-path /project \
     source.sol
```

--------------------------------

### Solidity Contract Member Usage Example

Source: https://docs.soliditylang.org/en/v0.8.30/types.html

This example demonstrates how to use contract members like address and selector. It includes a function 'f' that asserts the contract's address and returns its selector, and a function 'g' that calls 'f' with specific gas and value.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.4 <0.9.0;

contract Example {
    function f() public payable returns (bytes4) {
        assert(this.f.address == address(this));
        return this.f.selector;
    }

    function g() public {
        this.f{gas: 10, value: 800}();
    }
}

```

--------------------------------

### Sample Solidity Contract

Source: https://docs.soliditylang.org/en/v0.8.30/analysing-compilation-output.html

A basic Solidity contract used to demonstrate the generation of EVM assembly output.

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.5.0 <0.9.0;
contract C {
    function one() public pure returns (uint) {
        return 1;
    }
}
```

--------------------------------

### Using Legacy Libraries

Source: https://docs.soliditylang.org/en/v0.8.30/050-breaking-changes.html

Illustrates how to define an interface for a legacy library by declaring functions without implementation, enabling usage in modern contracts.

```solidity
library OldLibrary {
    function someFunction(uint8 a) public returns(bool);
}

contract NewContract {
    function f(uint8 a) public returns (bool) {
        return OldLibrary.someFunction(a);
    }
}
```

--------------------------------

### Solidity Contract Example: Mappings and Structs

Source: https://docs.soliditylang.org/en/v0.8.30/internals/layout_in_storage.html

Demonstrates a Solidity contract with nested mappings and a struct, illustrating the storage layout rules for complex data types. This example helps in understanding how to compute the storage location of specific members within nested mappings.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;


contract C {
    struct S { uint16 a; uint16 b; uint256 c; }
    uint x;
    mapping(uint => mapping(uint => S)) data;
}

```

--------------------------------

### Solidity Contract Inheritance with Event Emission (Initial Example)

Source: https://docs.soliditylang.org/en/v0.8.30/contracts.html

This example illustrates a scenario where explicit function overriding in Solidity might lead to unexpected event emission sequences if `super` is not used correctly. It defines base contracts and a final contract that overrides an event-emitting function.

```solidity
contract Emittable {
    event Emitted();
    function emitEvent() virtual public {
        emit Emitted();
    }
}

contract Base1 is Emittable {
    event Base1Emitted();
    function emitEvent() public virtual override {
        /* Here, we emit an event to simulate some Base1 logic */
        emit Base1Emitted();
        Emittable.emitEvent();
    }
}

contract Base2 is Emittable {
    event Base2Emitted();
    function emitEvent() public virtual override {
        /* Here, we emit an event to simulate some Base2 logic */
        emit Base2Emitted();
        Emittable.emitEvent();
    }
}

contract Final is Base1, Base2 {
    event FinalEmitted();
    function emitEvent() public override(Base1, Base2) {
        /* Here, we emit an event to simulate some Final logic */
        emit FinalEmitted();
        Base2.emitEvent();
    }
}
```

--------------------------------

### Define and Inherit Constructors in Solidity

Source: https://docs.soliditylang.org/en/v0.8.30/contracts.html

Demonstrates the basic usage of a constructor in a contract and how to inherit from a base contract by passing arguments in the constructor definition.

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;

abstract contract A {
    uint public a;

    constructor(uint a_) {
        a = a_;
    }
}

contract B is A(1) {
    constructor() {}
}
```

--------------------------------

### Import Remapped Library in Solidity

Source: https://docs.soliditylang.org/en/v0.8.30/path-resolution.html

Shows how to import a library in a Solidity source file after the compiler has been configured with a remapping.

```solidity
import "github.com/ethereum/dapp-bin/library/math.sol";
```

--------------------------------

### Solidity Library Internal Function Types Example

Source: https://docs.soliditylang.org/en/v0.8.30/types.html

This example showcases the use of internal function types within a Solidity library. The ArrayUtils library provides map, reduce, and range functions that can be used with pure internal functions. The Pyramid contract demonstrates how to use these library functions.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

library ArrayUtils {
    // internal functions can be used in internal library functions because
    // they will be part of the same code context
    function map(uint[] memory self, function (uint) pure returns (uint) f) 
        internal 
        pure 
        returns (uint[] memory r)
    {
        r = new uint[](self.length);
        for (uint i = 0; i < self.length; i++) {
            r[i] = f(self[i]);
        }
    }

    function reduce(
        uint[] memory self,
        function (uint, uint) pure returns (uint) f
    )
        internal
        pure
        returns (uint r)
    {
        r = self[0];
        for (uint i = 1; i < self.length; i++) {
            r = f(r, self[i]);
        }
    }

    function range(uint length) internal pure returns (uint[] memory r) {
        r = new uint[](length);
        for (uint i = 0; i < r.length; i++) {
            r[i] = i;
        }
    }
}


contract Pyramid {
    using ArrayUtils for *;

    function pyramid(uint l) public pure returns (uint) {
        return ArrayUtils.range(l).map(square).reduce(sum);
    }

    function square(uint x) internal pure returns (uint) {
        return x * x;
    }

    function sum(uint x, uint y) internal pure returns (uint) {
        return x + y;
    }
}

```

--------------------------------

### Run Solidity Tests on Windows

Source: https://docs.soliditylang.org/en/v0.8.30/contributing.html

Provides commands for running Solidity tests on Windows environments using Git Bash or the Command Prompt. It includes options to disable SMT tests if 'z3' is not available.

```shell
./build/test/Release/soltest.exe -- --no-smt
```

```shell
.\build\test\Release\soltest.exe -- --no-smt
```

--------------------------------

### Solidity External Function Types and Oracle Pattern Example

Source: https://docs.soliditylang.org/en/v0.8.30/types.html

This example demonstrates the use of external function types in Solidity, commonly used for callback mechanisms. The Oracle contract defines a structure for requests and allows external callbacks, while the OracleUser contract shows how to query the Oracle and handle the response.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.22 <0.9.0;


contract Oracle {
    struct Request {
        bytes data;
        function(uint) external callback;
    }

    Request[] private requests;
    event NewRequest(uint);

    function query(bytes memory data, function(uint) external callback) public {
        requests.push(Request(data, callback));
        emit NewRequest(requests.length - 1);
    }

    function reply(uint requestID, uint response) public {
        // Here goes the check that the reply comes from a trusted source
        requests[requestID].callback(response);
    }
}


contract OracleUser {
    Oracle constant private ORACLE_CONST = Oracle(address(0x00000000219ab540356cBB839Cbe05303d7705Fa)); // known contract
    uint private exchangeRate;

    function buySomething() public {
        ORACLE_CONST.query("USD", this.oracleResponse);
    }

    function oracleResponse(uint response) public {
        require(
            msg.sender == address(ORACLE_CONST),
            "Only oracle can call this."
        );
        exchangeRate = response;
    }
}

```

--------------------------------

### Solidity Array Initialization and Assignment

Source: https://docs.soliditylang.org/en/v0.8.30/types.html

Demonstrates initializing and assigning values to storage and memory arrays in Solidity. It shows how assignment to a storage array copies the memory array and replaces the complete storage array.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.6.0 <0.9.0;

contract ArrayContract {
    uint[2**20] aLotOfIntegers;
    bool[2][] pairsOfFlags;

    function setAllFlagPairs(bool[2][] memory newPairs) public {
        pairsOfFlags = newPairs;
    }

    struct StructType {
        uint[] contents;
        uint moreInfo;
    }
    StructType s;

    function f(uint[] memory c) public {
        StructType storage g = s;
        g.moreInfo = 2;
        g.contents = c;
    }

    function setFlagPair(uint index, bool flagA, bool flagB) public {
        pairsOfFlags[index][0] = flagA;
        pairsOfFlags[index][1] = flagB;
    }
}
```

--------------------------------

### Yul For-Loop with Break Statement Example

Source: https://docs.soliditylang.org/en/v0.8.30/yul.html

Demonstrates the legal usage of a 'break' statement within a nested for-loop structure in Yul. This example highlights that a 'break' can be in the body of an inner loop while also being in the update block of an outer loop, provided it adheres to the innermost loop's body restriction.

```Yul
for {} true {
  for {} true {}
  {
    break
  }
}
{
}

```

--------------------------------

### Build Solidity using build.sh script (Linux/macOS)

Source: https://docs.soliditylang.org/en/v0.8.30/installing-solidity.html

An easier method to build Solidity on Linux and macOS by executing a provided shell script. This script typically handles configuration and compilation, installing binaries to /usr/local/bin.

```bash
./scripts/build.sh
```

--------------------------------

### Solidity Contract Visibility Examples and Inheritance

Source: https://docs.soliditylang.org/en/v0.8.30/contracts.html

This example illustrates function and state variable visibility in Solidity, including external access, internal access, and inheritance. Contract 'D' attempts to access private and internal members of 'C' which fails compilation, while contract 'E' successfully accesses an internal function from its base contract 'C'.

```Solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.16 <0.9.0;

contract C {
    uint private data;

    function f(uint a) private pure returns(uint b) { return a + 1; }
    function setData(uint a) public { data = a; }
    function getData() public view returns(uint) { return data; }
    function compute(uint a, uint b) internal pure returns (uint) { return a + b; }
}

// This will not compile
contract D {
    function readData() public {
        C c = new C();
        uint local = c.f(7); // error: member `f` is not visible
        c.setData(3);
        local = c.getData();
        local = c.compute(3, 5); // error: member `compute` is not visible
    }
}

contract E is C {
    function g() public {
        C c = new C();
        uint val = compute(3, 5); // access to internal member (from derived to parent contract)
    }
}
```
Tokens:
Raw