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 goldenRatioDoubledThenSquaredSubprograms 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 81Finally, 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 yBlocks 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. Previous Lesson: Data Structures Next Lesson: Objects Table of Contents |