Pseudocode for the principal function of the sequence recognizer
program:  findRecog(k, lst).

The function findRecog takes two arguments: an integer depth limit
and a list of integers.  It tries to find a function that generates
the sequence whose first few elements match those given in the list.
The depth limit controls how many levels of recursion the function
is allowed to use before it gives up.

Function findRecog(integer k, list of integers lst)
  call a function that tests to see if lst satisfies the requirements
   for an arithmetic sequence and if so returns a function option
   with the function that generates that sequence; Return that function option.
  If it's not an arithemtic sequence, call a function that tests to see
   if lst satisfies the requirements for a geometric sequence, and if so
   returns a function option with the function that generates that sequence.
   Return that function option.
  If it's not a geometric sequence either, then call a function
   (let's call it findInterleavedRecog) that tests
   to see if the list can be expressed as an interleaving of two other
   sequences, and if so returns a function option for that.  Return that
   function option.
  If the last call returns NONE (because it could find an interleaved
   sequence within the depth limit) then return the function option NONE.

The function findInterleavedRecog also takes two arguments... of the
same forms as those of findRecog.  Here is pseudocode for it:

  
Function findInterleavedRecog(integer k, list of integers lst)
  If k = 0, then return NONE.
  Split the list into two new lists, evens and odds, alternating
  elements from the input list.
  Call findRecog on these lists with k-1 as the depth limit.
  If either of these calls returns NONE, then return NONE.
  Otherwise, return a function option for a function that
    uses the functions from the returned function options and
    generates the interleaved sequence.

Note that findInterleavedRecog and findRecog are co-recursive
  and must be defined with a single ML  fun declaration.