Subprograms
Functions

Subprograms are Mint's version of what are called 'functions' in other programming languages. To define a subprogram, use the keyword sub, followed by the name of the subprogram, and then a comma-separated list of parameters surrounded by parentheses.
sub square(x)
    return x ^ 2
end

sub max(x, y)
    when x > y
        return x
    return y
end

print max(60, square(30))    //Prints 900.
Subprograms return values using the return statement. Notice that in the above code, we defined x inside one subprogram and also in another. These two subprograms do not get confused about the value of x because each keeps their own separate x variable. The local variables of a subprogram only exist in that subprogram.

To write a single line function in Photon Mint, use the function keyword.
// In Photon Mint, a function's yields
// statement is the same as a subprogram's
// return statement.
// Mint's yields is not equivalent to Python's yield.
function f of x yields x*x
function twice of y yields 2(y)
function fOfTwice of k yields f(twice(k))

tenSquared = f(10)
eightDoubled = twice(8)
import math
goldenRatioDoubledThenSquared = fOfTwice(phi)
print tenSquared
print eightDoubled
print goldenRatioDoubledThenSquared
Subprograms can define other subprograms within themselves, and even return them.
Here is a subprogram that squares a subprogram:
sub squareSub(f)
    sub squared(x)
        return f(x) ^ 2
    end
    return squared
end

sub quadratic(x)
    return 3 * x ^ 2 + 6 * x - 15
end

g = squareSub(quadratic)
print g(9)
Subprograms support closures, which means they can enclose data and even form their own data structures.
sub tripleList(a, b, c)
    sub get(i)
        if i == 0
            return a
        else if i == 1
            return b
        else
            return c
        end
    end
    return get
end

x = tripleList(6, 7, 81)
print x(0)    //Prints 6
print x(2)    //Prints 81
Finally, subprograms support recursion. You have the ability to call a subprogram within itself.
sub factorial(x)
    when x <= 1
        return 1
    return x * factorial(x - 1)
end

sub fib(n)
    when n <= 1
        return n
    return fib(n - 1) + fib(n - 2)
end

print factorial(8)
print fib(11)
There is a simple version of a subprogram known as a block. You enter a block by using the run keyword, and you exit a block using the leave keyword.
block doSomething
    y.reverse()
    leave
end

y = ["a", "b", "c", "d"]
run doSomething
print y
Blocks are run just like subprograms, except that subprograms create their own new scope for variables, while blocks modify existing variables.
This is why the block 'doSomething' is able to modify the variable y in the global scope.

You can make infinitely large lists by creating a list out of a subprogram.
sub g(x)
    import math
    x = BigInt(x)
    return factorial(x)
end

import type
y = list(g)     //y represents the factorial of all integers
print y         //Prints [1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, ...]
print y[1000]   /* Prints a very large number. */
In this example we used the BigInteger type to represent factorials of large numbers. Creating a list out of a subprogram f will define list[x] as f(x) for all x that f is defined.

Navigation
Previous Lesson: Data Structures
Next Lesson: Objects
Table of Contents