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

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

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 Mint, use the function keyword.
// In 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
    return squared

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

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
            return c
    return get

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)

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

print factorial(8)
print fib(11)
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)

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.

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