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