stdlib.mon

//
// This file contains functions available by default, implemented in 100%
// pure monkey.
//
// i.e. This is part of our standard-library.
//
// If you wish to make changes to the standard-library functions in this
// file you'll need to rebuild the interpreter after making your changes.
//
// This file it is embedded in the generated-binary as part of the build
// process.
//
//    go build .
//


//
// Mathematical constants
//
const PI = 3.141592653589793;
const E  =  2.718281828459045;

//
// File-objects for STDIN, STDOUT, and STDERR.
//
// Rather than opening these by name/path we have magic-strings which
// are recognized by our "open" primitive.
//
const STDIN = open( "!STDIN!" );
const STDOUT = open( "!STDOUT!" );
const STDERR = open( "!STDERR!" );


//
// Functions with an "object." prefix are available to all types.
//
// With this definition in-place you can invoke the object-methods:
//
//     "".type();
//     3.type();
//     [].type();
//     etc
//
// instead of having to run type( blah );
//
function object.type() {
   return(type(self));
}


//
// Functions with an "object." prefix are available to all types.
//
// With this definition in-place you can invoke the object-methods:
//
//     "".string();
//     3.string();
//     [].string();
//     etc
//
// instead of having to run string( blah );
//
function object.string() {
   return(string(self));
}




//
// The `assert` method allows the code in our standard-library to be
// tested every time it is loaded.
//
function assert(val, msg = "Result was not 'true'!" ) {
   if ( type(val) == "string") {
      result = eval( val );
      if ( !result ) {
        puts( "assert(\"" , val, "\") failed - ", msg, "\n" );
        exit(1);
      }
   }
   else {
      if ( ! val ) {
        puts( msg, "\n" );
        exit(1);
      }
  }
}

assert( "true" );
assert( true );
assert( "! false;" );
assert( !false );
assert( "type( STDIN ) == \"file\"" );
assert( "type( STDOUT ) == \"file\"" );
assert( "type( STDERR ) == \"file\"" );


//
// First element of an array
//
function first( array ) {
  if ( len(array) >= 1 ) {
    return( array[0] );
  }

  // return nil is implicit here.
}

assert( "first( [0,1] ) == 0" );
assert( "first([\"steve\",1]) == \"steve\"" );
assert( "!first([])" );



//
// The rest of an array - i.e. all elements EXCEPT the first
//
function rest( array ) {
  let result = [];

  if ( len(array) > 1 ) {
    let i = 1;
    for( i < len(array) ) {
      result = push(result, array[i]);
      i++;
    }
   }
   return result;
}

assert( "type(rest([])) == \"array\"" );
assert( "len(rest( [0,2] ) ) == 1" );
assert( "len(rest( [0,1,2] ) ) == 2" );
assert( "len(rest( [0,1,2,3,4,5] ) ) == 5" );
assert( "string(rest([\"steve\",1])) == \"[1]\"" );



//
// Last element of an array
//
function last( array ) {
  if ( len( array ) > 0 ) {
    return(array[len(array)-1]);
  }

  // `return null` is implicit here.
}

assert( "last([0,2]) == 2" );
assert( "!last([])" );





//
// Is the given array empty?
//
function array.empty?() {
   if ( len(self) == 0 ) {
      return true;
   }
   return false;
}

assert( "[].empty?()" );
assert( "![1,2].empty?()" );
assert( "![\"steve\",3].empty?()" );





//
// Call the given function on each entry, and return an array of the
// items for which the predicate returned true.
//
function array.filter( predicate ) {
   let i = 0;
   let l = len(self);
   let result = [];

   for( i < l ) {
      let entry = self[i];
      if (predicate(entry)) {
         let result = push( result, entry );
      }
      i++;
   }

   return result;
}


// Filter an array and keep only values which are "2".
assert( "let a = [ 1, 2, 3 , -1, \"steve\", 44 ];
         let a = a.filter( fn(n) { return n == 2 ; } );
         if ( a.string() == \"[2]\" ) {
             return true;
         } else {
             puts( a );
             return false;
         }" );




//
// Return the offset, if any, of the specified item in the array.
//
function array.find(item) {
   foreach index, value in self {
       if ( value == item ) {
           return index;
       }
   }

   // not found.
   return -1;
}

assert( "[1,2,3].find(7) == -1" );
assert( "[1,2,3].find(1) == 0" );
assert( "[1,2,3].find(3) == 2" );
assert( "[1,2,3,3].find(3) == 2" );



//
// Does the given value exist inside the array?
//
function array.includes?( obj ) {
   return( self.find( obj ) != -1 );
}

assert( "[1,2,3].includes?(2)" );
assert( "! [1,2,3].includes?(23)" );

//
// Find minimum value in array
//
function array.min() {

   let i = 0;

   let l = len(self);
   if ( l < 1 ) {
      return 0;
   }

   // Assume first value is minimum
   let min = self[0];

   // type checking.
   if ( type(min) != "integer" && type(min) != "float" ) {
      puts( "array.min only works on numbers - not " , type(min), "\n");
      exit(1);
   }

   // If we find a smaller one, set it.
   for( i < l ) {

     // type checking.
     if ( type(self[i]) != "integer" && type(self[i]) != "float" ) {
        puts( "array.min only works on numbers - not " , type(self[i]), "\n");
        exit(1);
     }

     if ( self[i] < min ) {
       min = self[i];
     }
     i++;
   }

   return min;
}

assert( "( [1,2,3].min() == 1 )" );
assert( "( 1..10.min() == 1 )" );
assert( "( [-1,-2,-3].min() == -3 )" );
assert( "( [].min() == 0 )", "minimum of an empty array is zero" );


//
// Find maximum value in array
//
function array.max() {

   let i = 0;

   let l = len(self);
   if ( l < 1 ) {
      return 0;
   }

   // Assume first value is maximum
   let max = self[0];

   // ensure we're dealing with types
   if ( type(max) != "integer" && type(max) != "float" ) {
      puts( "array.max only works on numbers - not " , type(max), "\n");
      exit(1);
   }

   // If we find a greater one, set it.
   for( i < l ) {

     // type checking.
     if ( type(self[i]) != "integer" && type(self[i]) != "float" ) {
        puts( "array.max only works on numbers - not " , type(self[i]), "\n");
        exit(1);
     }

     if ( self[i] > max ) {
       max = self[i];
     }
     i++;
   }

   return max;
}

assert( "( 1..15.max() == 15 )" );
assert( "( [1,2,3].max() == 3 )" );
assert( "( [-1,-2,-3].max() == -1 )" );
assert( "( [].max() == 0 )", "maximum of an empty array is zero" );


//
// Join the elements of an array by the given string.
//
function array.join( char ) {
   let r = "";
   let i = 0;
   let l = len(self);

   // For each entry.
   for( i < l ) {

     // If the result is non-empty add the separator.
     if ( len(r) > 0 ) {
       r+= char;
     }

     // add on the next element.
     r += string(self[i])
     i++;
   }

   return r;
}

assert( "[1,2,3].join( \".\" ) == \"1.2.3\"" );
assert( "[1,2,3].join( \"\" ) == \"123\"" );






//
// Reverse an array.
//
function array.reverse() {
  let r = [];
  let l = len(self);

  for( l > 0 ) {
     let r = push( r, self[l-1] );
     l--;
  }
  return r;
}

assert( "string([1,2,3].reverse()) == \"[3, 2, 1]\"" );






//
// sorted? returns true if the specified array is sorted.
//
function array.sorted?() {

  // Ensure each array-member has the same type.
  let tmp = {};
  let i = 0;

  // Record the types.
  for( i < len(self) ) {
     tmp = set(tmp, self[i].type(), true );
     i++;
  }

  // There can be only one!
  if ( len( keys( tmp ) ) > 1 ) {
     puts( "Attempting to check an array with mixed-type values!\n" );
     puts( string(self), "\n" );
     exit(1);
  }

  let i = 1;
  let l = len(self);

  // Array of zero/one element is always sorted.
  if ( l < 2 ) {
    return true;
  }

  // If a later item is smaller than the
  // earlier item the array is not sorted.
  for( i < l ) {
     if ( self[i] < self[i-1]) {
       return false;
     }
     i++;
  }

  return true;
}

assert( "[-1,0,1].sorted?()" );
assert( "[1].sorted?()" );
assert( "[].sorted?()" );







//
// Swap the value of two array indexes.
//
// This is used by our sorting function.  Currently it isn't possible
// to mutate an array-member in-place.  So we create a new array
// correctly swapping the values at the given index.
//
// This would be easier if we had "elseif" support, or even a case
// statement.  (Due to the nested if usage here.)
//
function array.swap( a, b ) {
  let aVal = self[b];
  let bVal = self[a];

  let r = [];
  let i = 0;
  let l = len(self);

  for( i < l ) {
     if ( i == a ) {
        let r = push(r, aVal);
     } else {
        if ( i == b ) {
           let r = push(r,bVal );
        } else {
           let r = push( r, self[i] );
        }
     }
     i++;
  }

  return r;
}

assert( "let a = [10,20]; a = a.swap(0,1); if ( a[0] == 20 ) { true; } else { false ; }" );
assert( "let a = [10,20]; a = a.swap(0,1); if ( a[1] == 10 ) { true; } else { false ; }" );






//
// Sort the given array.
//
// This is grossly inefficient, obviously.
//
function array.sort() {

  // Ensure each array-member has the same type.
  let tmp = {};
  let i = 0;

  // Record the types.
  for( i < len(self) ) {
     tmp = set(tmp, self[i].type(), true );
     i++;
  }

  // There can be only one!
  if ( len( keys( tmp ) ) > 1 ) {
     puts( "Attempting to sort an array with mixed-type values!\n" );
     puts( string(self), "\n" );
     exit(1);
  }

  // While the given array isn't sorted.
  for( ! self.sorted?() ) {

     // make a pass over the array.
     let i = 1;
     let l = len(self);
     for( i < l ) {

        // if this element is wrong swap it.
        if ( self[i] < self[i-1] ) {
          self = self.swap( i-1, i);
        }
        i++;
     }
  }

  // Should be done now.
  return self;
}

assert( "let a = [ 3, 2, 1 ]; a = a.sort(); a.sorted?()" );
assert( "let a = [ 3, 2, 1 ]; a = a.sort(); a[0] == 1" );
assert( "let a = [ 3, 2, 1 ]; a = a.sort(); a[1] == 2" );
assert( "let a = [ 3, 2, 1 ]; a = a.sort(); a[2] == 3" );



//
// Return an array containing the result of applying the specified
// function to each element in the array.
//
// This is out of alphabetical order because our assert-based testing
// invokes sort, just to ensure consistent results.
//
function array.map( fnc ) {

   let result = [];

   foreach item in self {
      let result = push( result, fnc(item) );
   }

   return result;
}


assert( "let a = [3,9,-4];
         a = a.map(fn(n) { return n * n; });
         a = a.sort();
         if( a.string() == \"[9, 16, 81]\" ) {
           true;
         } else {
           false;
         }" );
assert( "let a = [2,-1,-12];
         a = a.map(fn(n) { return n +2; });
         a = a.sort();
         if( a.string() == \"[-10, 1, 4]\" ) {
           true;
         } else {
           false;
         }" );



//
// array.uniq returns the unique members of an array.
//
function array.uniq() {
    tmp = {};

    foreach item in self {
         tmp = set( tmp, item, true );
    }

    // return the sorted keys
    return( tmp.keys().sort() );
}

assert( "string([1,1,1,1,2].uniq()) == \"[1, 2]\"" );







//
// Convert a float to an integer.
//
// Like Go we discard the value after the period, so 4.9 will become 4.
//
function float.to_i() {
   return( int( self ) );
}

assert( "type( 3.1.to_i() ) == \"integer\"" );
assert( "let a = 3.1; if ( a.to_i() == 3 ) { return true; } else { return false ; } " );






//
// Is the given hash empty?
//
function hash.empty?() {
   if ( len(self.keys()) == 0 ) {
      return true;
   }
   return false;
}

assert( "{}.empty?()" );
assert( "! {\"name\":\"steve\"}.empty?()" );







//
// Convert an integer to a float.
//
function integer.to_f() {
   return( self + 0.0);
}

assert( "type( 3.to_f() ) == \"float\"" );
assert( "3.to_f() == 3.0" );





//
// Count occurences of the given character in the string.
//
function string.count(char) {
  let c = 0;

  foreach chr in self {
     if ( chr == char ) {
        c += 1;
     }
  }

  return c;
}

assert( "\"steve\".count(\"e\") == 2" );
assert( "\"steve\".count(\"E\") == 0" );
assert( "\"犬狐\".count(\"狐\") == 1" );
assert( "\"犬犬犬犬犬犬狐\".count(\"犬\") == 6" );





//
// Remove leading whitespace from the string.
//
function string.ltrim() {
   let reg = "^(\\s+)(.*)$";
   let out = match(reg, self);

   if ( out ) {
      return( out[1]) ;
   } else {
      return self;
   }
}

assert( ( "  狐犬  ".ltrim() == "狐犬  "), "string.ltrim failed" );
assert( ( "  steve  ".ltrim() == "steve  "), "string.ltrim failed" );







//
// Repeat a string N times.
//
function string.repeat(count) {
  let r= "";

  if ( count < 1 ) {
     return self;
  }
  for( count > 0 ) {
     r += self;
     count--;
  }
  return r;
}

assert( ( "狐犬".repeat(3) == "狐犬狐犬狐犬"), "string.repeat failed" );
assert( ( "*".repeat(1) == "*"), "string.repeat failed" );
assert( ( "*".repeat(0) == "*"), "string.repeat failed" );
assert( ( "*".repeat(-1) == "*"), "string.repeat failed" );






//
// Reverse a string,
//
function string.reverse() {
  let r= "";
  let l = len(self);

  for( l > 0 ) {
     r += self[l-1];
     l--;
  }
  return r;
}

assert( ( "狐犬".reverse() == "犬狐"), "string.reverse failed" );
assert( ( "322".reverse() == "223"), "string.reverse failed" );






//
// Remove trailing whitespace from the string.
//
function string.rtrim() {
   let reg = "^(.*?)(\\s*)$";
   let out = match(reg, self);

   if ( out ) {
      return( out[0]) ;
   } else {
      return self;
   }
}

assert( ( "  狐犬  ".rtrim() == "  狐犬"), "string.rtrim failed" );





// string.substr returns the given substring
// from our input.  The length of the string
// to return is optional, and will default to
// the length available.
//
// Note: Moved this ahead of where it is used in string.replace.
//
function string.substr(start,length = -1) {

   // if there is no length then default to the rest of the string.
   if ( length == -1 ) {
     length = len(self) - start ;
   }

   // start must be positive
   if ( start < 0 ) {
     start = 0;
   }

   // if the length of the string is too big then we'll cap it too.
   if ( start + length > self.len() ) {
     length = len(self) - start ;
   }

   // catch bounding-errors.
   if ( start >= len(self) ) {
      return "";
   }

   let res = "";
   let copied = 0;

   for( (start < len(self)) && ( copied < length ) ) {
     res += self[start];
     start++;
     copied++;
   }
   return( res );
}

assert( "Hello world".substr( 1,4 ) == "ello" , "string.substr() failed");
assert( "Hello world".substr( 6 ) == "world" , "string.substr() failed");
assert( "狐犬".substr( 0 ) == "狐犬" , "string.substr() failed");
assert( "犬狐".substr( 1 ) == "狐" , "string.substr() failed");
assert( "狐犬".substr( 2 ) == "" , "string.substr() failed");
assert( "狐犬".substr( 0,2 ) == "狐犬" , "string.substr() failed");
assert( "狐犬".substr( 1,2 ) == "犬" , "string.substr() failed");
assert( "狐犬".substr( 1,100 ) == "犬" , "string.substr() failed");
assert( "狐犬".substr( -1,100 ) == "狐犬" , "string.substr() failed");




//
// string.find returns the offset of the given substring
// or -1 if it isn't found.
//
function string.find( needle ) {

   // get details about ourself
   let i = 0;
   let l = len(self);

   // the length of our search string.
   let L = len(needle);

   // get a substring at each possible position
   for( i < l ) {
     possible = self.substr( i, L );

     // does this match?
     if ( possible == needle ) {
       return i;
     }

     i++;
   }

   return -1;
}


assert( "\"steve\".find(\"e\" ) == 2" );
assert( "\"steve\".find(\"v\" ) == 3" );
assert( "\"steve\".find(\"PIE\" ) == -1" );
assert( "\"狐犬\".find(\"狐犬\" ) == 0" );
assert( "\"st狐eve犬es\".find(\"犬\" ) == 6" );




//
// string.interpolate replaces ${blah} with the value of "blah" from
// the specified hash.
//
function string.interpolate( hsh ) {
   let reg = "(?s)^(.*?)\\$\\{([^\\}]+)\\}(.*)";
   let out = match(reg, self);

   for( out ) {

      let pre = out[0];
      let tok = out[1];
      let pst = out[2];

      let self = pre + string(hsh[tok]) + pst;
      let out = match(reg, self);
   }
   return( self );
}



//
// string.split returns an array splitting on any characters included
// in the separator string.
//
// By default the split is on whitespace: " ", "TAB", & "RETURN".
//
function string.split(sep = " \r\t\n" ) {
  let i = 0;
  let l = len(self);
  let r = [];

  let tmp = "";

  for( i < l ) {

     // get the character.
     let c = self[i];

     // is the character one of our split-characters?
     if ( sep.find( c ) != -1 ) {

        // OK push any previously-accumulated token into our array.
        if ( len(tmp) > 0 ) {
          r = push( r, tmp );
        }
        tmp = "";

     } else {

       // store the character into our accumulator.
       tmp += c;
     }
     i++;
  }

  // Do we have a dangling-string?  If so append it.
  if ( len(tmp) > 0 ) {
     r = push(r,tmp);
  }

  return r;
}

assert( "len(\"1 2 3\".split()) == 3" );
assert( "type(\"1 2 3\".split(\"2\")) == \"array\"" );









//
// string.replace removes a value from a string, replacing it
// with a new value.
//
function string.replace( old, new ) {
  let s = self;
  let index = s.find( old );

  for( index >= 0 ) {

     // get the prefix
     let pre = s.substr(0, index);

     // get the suffix
     let suf = s.substr( index + len(old) );

     s = pre + new + suf;

     index = s.find( old );
  }

  return s;
}

assert( "steve".replace( "e", "E" ) == "stEvE", "string.replace() failed" );
assert( "steve".replace( "A", "EE" ) == "steve", "string.replace() failed" );







//
// Trim leading & trailing whitespace from the given string.
//
function string.trim() {
   let l = self.ltrim();
   return( l.rtrim() );
}

assert( "  ".trim() == "", "string.trim failed" );
assert( " 1 ".trim() == "1", "string.trim failed" );






//
// Convert the given string to lower-case.
//
function string.tolower() {
   let r = "";

   foreach char in self {
      if ( char >= "A" && char <= "Z" ) {
           char = char.ord();
           char += 32;
           char = char.chr();
      }
      r += char;
   }

   return r;
}

assert( "Steve".tolower() == "steve", "string.tolower() failed" );
assert( "狐犬".tolower() == "狐犬", "string.tolower() failed" );








//
// Convert a string to a number
//
// (Possibly an int, possibly a float)
//
function string.to_number() {
   let reg = "\\.";
   let out = match(reg, self);

   if ( out ) {
      return( self.to_f() );
   } else {
      return( self.to_i() );
   }
}

assert( "3.13".to_number() == 3.13, "string.tonumber() failed" );
assert( type("3.13".to_number() ) == "float", "string.tonumber() failed" );
assert( "313".to_number() == 313, "string.tonumber() failed" );
assert( type("313".to_number() ) == "integer", "string.tonumber() failed" );








//
// Convert the given string to upper-case.
//
function string.toupper() {
   let r = "";

   foreach char in self {
      if ( char >= "a" && char <= "z" ) {
           char = char.ord();
           char -= 32;
           char = char.chr();
      }

      r += char;
   }

   return r;
}

assert( "steve".toupper() == "STEVE", "string.toupper() failed" );
assert( "狐犬".toupper() == "狐犬", "string.toupper() failed" );