Sidebar
This is an old revision of the document!
Table of Contents
2.3.4.8.4.6 Pure Methods
Overview
Pure methods are limited to are often referred to as Pure Functions. Pure Functions are a cornerstone in Functional Programming and are designed to produce no Side Effects. Pure Functions are characterized as follows1):
- Are dependent only on
- Declared input parameters
- Algorithm to implemented
- Values within the scope of the function, therefore, it can not
- Depend on accessing any values defined outside the function scope (i.e., another field in the same class, or global variables)
- Modify mutable values outside the function scope (i.e., other fields in the same class, or global variables)
- Use external input or output (I/O). It can’t rely on input from files, databases, web services, UIs, etc; it can’t produce output, such as writing to a file, database, or web service, writing to a screen, etc.
Do not modify input parametersFigure 1 provides a grapic represeting a Pure Function. Basically, the Pure FUnction is an isolated piece of logic that given the same input always produces the same output. It's isolation means it has no unintended sideeffects outside of itself and only the inputs determine the processing. Another way to think of a Pure Function is at their center there is a Deterministic Algorithm (Also see Black Box Testing).
Figure 1: Pure functionsIn some languages (i.e., C, C++, Rust, PHP, JavaScript/ECMAScript), it is possible to have methods (i.e., procedures or functions) existing outside the
classcontainer. Java and C# requires operations to exist within aclasscontainer, and therefore does not support General Methods. C++ does not recommend having General Methods outside of aclass, but because C++ is more or less an extension of C, it does support them.Often, the architecture and design of Functional Programs depends on the identification, design and creation of pluggable, reusable functions. Many of the frameworks used in modern applications reaching across many tiers rely heavily on stateless, client-server Representational State Transfer (REST) models and Command Line Interfaces (CLIs) .
Figure 2 graphically represents pure functions used in a Functional Program.
- The pure functions used in the Functional Program are identified (See items
A,B, andC) - The
functionsare from a reuse repository (i.e., library), or they can be created especially for the new Functional Program - The Functional Program is responsible for the lifecycle of each data element (i.e., State Variables)
- The order of the
functionsis established in the Functional Program - The association is made of the
functionswith appropriate the State Variables (which areInput Dataand which areOutput Data) - The Functional Program is executed:
- The Functional Program is started
- Calls are made to the
functionsin the desired order (i.e., steps 2-4) and the State Variable values are passed into or out of thefunctions - The Functional Program is terminated
Figure 2: The use of pure Functions in a Functional ProgramDIDO Specifics
Ethereum's Solidity is an Object-Oriented Programming (OOP) supporting four closely related object container types (Java and C++ have just one
class):contract Contracts in Solidity are similar to classes in object-oriented languages. They contain persistent data in state variables, and functions that can modify these variables. Calling a function on a different contract (instance) will perform an EVM function call and thus switch the context such that state variables in the calling contract are inaccessible. A contract and its functions need to be called for anything to happen. There is no “cron” concept in Ethereum to call a function at a particular event automatically. interface Interfaces are similar to abstract contracts, but they cannot have any functions implemented. There are further restrictions: - They cannot inherit from other contracts, but they can inherit from other interfaces.
- All declared functions must be external.
- They cannot declare a constructor.
- They cannot declare state variables.
- They cannot declare modifiers.
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 an interface should be possible without any information loss.
library Libraries are similar to contracts, but their purpose is that they are deployed only once at a specific address and their code is reused using the DELEGATECALLfeature of the EVM.This means that if library functions are called, their code is executed in the context of the calling contract, i.e. this points to the calling contract, and especially the storage from the calling contract can be accessed. As a library is an isolated piece of source code, it can only access state variables of the calling contract if they are explicitly supplied (it would have no way to name them, otherwise). Library functions can only be called directly (i.e. without the use of
DELEGATECALL) if they do not modify the state (i.e. if they are view or pure functions), because libraries are assumed to be stateless. In particular, it is not possible to destroy a library.Libraries can be seen as implicit base contracts of the contracts that use them. They will not be explicitly visible in the inheritance hierarchy, but calls to library functions look just like calls to functions of explicit base contracts (using qualified access like L.f()). Of course, calls to internal functions use the internal calling convention, which means that all internal types can be passed and types stored in memory will be passed by reference and not copied. To realize this in the EVM, code of internal library functions and all functions called from therein will at compile time be included in the calling contract, and a regular JUMP call will be used instead of a
DELEGATECALL.struct 1)Alvin Alexander, AlvinAlexander.com, The Definition of “Pure Function”, Accessed: 30 December 2021, https://alvinalexander.com/scala/fp-book/definition-of-pure-function/
dido/public/ra/1.2_views/3_taxonomic/4_data_tax/08_objects/07_opers/09_general.1641086676.txt.gz · Last modified: 2022/01/01 20:24 by nickTranslations of this page:
