Hello everyone..
Welcome to another day in in exploring Web3 Engineering.
Since we are exploring the Move language for Sui Smart contract development. Today, let us look into the different types of functions provided by the language, function declarations, calling, visibility etc., So, without any further ado, let's get started.
Function Declaration
The move functions are declared using the fun keyword. And the syntax is as follows:
<visibility>? fun <identifier>(arg: arg_type, ...): <return_type> {}
And example function will look like this
public fun sum(a: u128, b: u128): u128 {
a + b
}
Since move is inspired from the Rust, it also follows the same pattern for returning values. The last statement with no semicolon is implicitly considered as return statement. The language also have a return keyword, if we want to explicitly mention it.The move functions can return
Function calling
When calling a function, the name can be specified either through an alias or fully qualified.
module a::example {
public fun zero(): u64 { 0 }
}
module b::other {
use a::example::{Self, zero};
fun call_zero() {
a::example::zero();
example::zero();
zero();
}
}
Types of function
Move language has different kinds of function. They are
Regular Functions
The regular functions are the simplest functions that have any number of arguments and returns any number of arguments. They are defined as shown above.
Entry Functions
Entry functions are considered as the entry point of the execution. These are usually used to define a function that contains the core logic, and can only be called the functions in the same module. Entry functions are defined entry and the syntax is as follows. The entry functions are by default not exposed to another contracts.
module a::m {
entry fun foo(): u64 { 0 }
fun calls_foo(): u64 { foo() }
}
Friend Functions - Deprecated
Functions in other modules can be declared as a friend as a trusted source. The syntax is as follows. A friend is declared using the friend keyword followed by the location of the function.
module 0x42::a {
use module_b;
use module_c::function_3;
friend 0x43::function_1;
friend module_b::function_2;
friend function_3;
}
Visibility
The move language supports 3 kinds of visibility specifiers. They are
Public - Any function declared as public can be called by any source. Declared using the keyword public.
Private - The move functions by default are private. They are only accessible by the functions withing the module.
Public(Package) - The public package is a more restricted form of public visibility. It allows a function to be accessed publicly just within that package but not to outside sources. It is declared by using the keyword public(package) keyword.
- Before the addition of public(package), public(friend) was used to allow limited public access to functions in the same package, but where the list of allowed modules had to be explicitly enumerated by the callee's module.
With that we are done with the functions on the move smart contracts. Let us look into the Struct data structure provided by the move lang in the next one.
