laser 0.7.0.pre1

data/lib/laser/standard_library/comparable.rb

@@ -0,0 +1,125 @@
+##
+# LICENSING: Taken from Rubinius.
+# Retrieved from https://github.com/rubinius/rubinius/blob/master/kernel/common/comparable.rb
+# on 7/25/2011
+# commit de03069d21839235fd59
+#
+# The Comparable mixin is used by classes whose objects may be ordered. The
+# class must define the <tt><=></tt> (spaceship) operator, which compares the
+# receiver against another object, returning -1, 0, or +1 depending on whether
+# the receiver is less than, equal to, or greater than the other object.
+#
+# Comparable uses <tt><=></tt> to implement the conventional comparison
+# operators (<tt><</tt>, <tt><=</tt>, <tt>==</tt>, <tt>>=</tt>, and
+# <tt>></tt>) and the method <tt>between?</tt>.
+#
+#   class SizeMatters
+#     include Comparable
+#     attr :str
+#     def <=>(other)
+#       str.size <=> other.str.size
+#     end
+#     def initialize(str)
+#       @str = str
+#     end
+#     def inspect
+#       @str
+#     end
+#   end
+#
+#   s1 = SizeMatters.new "Z"
+#   s2 = SizeMatters.new "YY"
+#   s3 = SizeMatters.new "XXX"
+#   s4 = SizeMatters.new "WWWW"
+#   s5 = SizeMatters.new "VVVVV"
+#
+#   s1 < s2                       #=> true
+#   s4.between? s1, s3            #=> false
+#   s4.between? s3, s5            #=> true
+#   [ s3, s2, s5, s4, s1 ].sort   #=> [Z, YY, XXX, WWWW, VVVVV]
+
+module Comparable
+
+  # Compares two objects based on the receiver's <code><=></code>
+  # method, returning true if it returns 0. Also returns true if
+  # _obj_ and _other_ are the same object.
+  def ==(other)
+    return true if equal?(other)
+
+    begin
+      unless comp = (self <=> other)
+        return nil
+      end
+
+      return Comparable.compare_int(comp) == 0
+    rescue StandardError
+      return nil
+    end
+  end
+
+  #  Compares two objects based on the receiver's <code><=></code>
+  #  method, returning true if it returns 1.
+  def >(other)
+    unless comp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class}"
+    end
+
+    Comparable.compare_int(comp) > 0
+  end
+
+  #  Compares two objects based on the receiver's <code><=></code>
+  #  method, returning true if it returns 0 or 1.
+  def >=(other)
+    unless comp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class}"
+    end
+
+    Comparable.compare_int(comp) >= 0
+  end
+
+  #  Compares two objects based on the receiver's <code><=></code>
+  #  method, returning true if it returns -1.
+  def <(other)
+    unless comp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class}"
+    end
+
+    Comparable.compare_int(comp) < 0
+  end
+
+  #  Compares two objects based on the receiver's <code><=></code>
+  #  method, returning true if it returns -1 or 0.
+  def <=(other)
+    unless comp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class}"
+    end
+
+    Comparable.compare_int(comp) <= 0
+  end
+
+  #  Returns <code>false</code> if <i>obj</i> <code><=></code>
+  #  <i>min</i> is less than zero or if <i>anObject</i> <code><=></code>
+  #  <i>max</i> is greater than zero, <code>true</code> otherwise.
+  #
+  #     3.between?(1, 5)               #=> true
+  #     6.between?(1, 5)               #=> false
+  #     'cat'.between?('ant', 'dog')   #=> true
+  #     'gnu'.between?('ant', 'dog')   #=> false
+  #
+  def between?(min, max)
+    # This could be more elegant, but we need to use <= and => on self to match
+    # MRI.
+    return false if self < min
+    return false if self > max
+    return true
+  end
+
+  # A version of MRI's rb_cmpint (sort of)
+  def self.compare_int(int)
+    return int if int.kind_of? Fixnum
+
+    return 1  if int > 0
+    return -1 if int < 0
+    return 0
+  end
+end

data/lib/laser/standard_library/complex.rb

@@ -0,0 +1,162 @@
+class Complex
+  # pure: true
+  # builtin: true
+  # returns: Complex=
+  def *(other)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Complex=
+  def **(other)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Complex=
+  def +(other)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Complex=
+  def -(other)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Complex=
+  def -@
+  end
+  # pure: true
+  # builtin: true
+  # returns: Complex=
+  def /(other)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Boolean
+  # raises: never
+  def ==(other)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Float= | Fixnum= | Bignum=
+  # raises: never
+  def abs
+  end
+  alias magnitude abs
+  # pure: true
+  # builtin: true
+  # returns: Float= | Fixnum= | Bignum=
+  # raises: never
+  def abs2
+  end
+  # pure: true
+  # builtin: true
+  # returns: Float=
+  # raises: never
+  def angle
+  end
+  alias arg angle
+  alias phase angle
+  def coerce(other)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Complex=
+  # raises: never
+  def conj
+  end
+  alias conjugate conj
+  # pure: true
+  # builtin: true
+  # returns: Fixnum= | Bignum=
+  # raises: never
+  def denominator
+  end
+  # pure: true
+  # builtin: true
+  # returns: Boolean
+  # raises: never
+  def eql?(other)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Complex=
+  # raises: never
+  def fdiv(other)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Fixnum= | Bignum=
+  # raises: never
+  def hash
+  end
+  # pure: true
+  # builtin: true
+  # returns: Float= | Fixnum= | Bignum=
+  # raises: never
+  def imag
+  end
+  alias imaginary imag
+  # pure: true
+  # builtin: true
+  # returns: String=
+  def inspect
+  end
+  # pure: true
+  # builtin: true
+  # returns: Complex=
+  # raises: never
+  def numerator
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  # raises: never
+  def polar
+  end
+  alias quo /
+  # pure: true
+  # builtin: true
+  # returns: Rational=
+  def rationalize(eps=nil)
+  end
+  # pure: true
+  # builtin: true
+  # returns: Float= | Fixnum= | Bignum=
+  # raises: never
+  def real
+  end
+  # pure: true
+  # builtin: true
+  # returns: Boolean
+  # raises: never
+  def real?
+  end
+  # pure: true
+  # builtin: true
+  # returns: Array=
+  # raises: never
+  def rect
+  end
+  alias rectangular rect
+  # pure: true
+  # builtin: true
+  # returns: Float=
+  def to_f
+  end
+  # pure: true
+  # builtin: true
+  # returns: Integer=
+  def to_i
+  end
+  # pure: true
+  # builtin: true
+  # returns: Rational=
+  def to_r
+  end
+  # pure: true
+  # builtin: true
+  # returns: String=
+  # raises: never
+  def to_s
+  end
+end

data/lib/laser/standard_library/enumerable.rb

@@ -0,0 +1,178 @@
+module Enumerable
+  # builtin: true
+  # pure: true
+  def all?
+  end
+  # builtin: true
+  # pure: true
+  def any?
+  end
+  # builtin: true
+  # pure: true
+  def chunk(initial_state = nil)
+  end
+  # builtin: true
+  # pure: true
+  def collect
+  end
+  # builtin: true
+  # pure: true
+  def collect_concat
+  end
+  # builtin: true
+  # pure: true
+  def count(*args)
+  end
+  # builtin: true
+  # pure: true
+  def cycle(n=nil)
+  end
+  # builtin: true
+  # pure: true
+  def detect(ifnone=nil)
+  end
+  # builtin: true
+  # pure: true
+  def drop(n)
+  end
+  # builtin: true
+  # pure: true
+  def drop_while
+  end
+  # builtin: true
+  # pure: true
+  def each_cons(n)
+  end
+  # builtin: true
+  # pure: true
+  def each_entry
+  end
+  # builtin: true
+  # pure: true
+  def each_slice(n)
+  end
+  # builtin: true
+  # pure: true
+  def each_with_index(*args)
+  end
+  # builtin: true
+  # pure: true
+  def each_with_object(obj)
+  end
+  # builtin: true
+  # pure: true
+  def entries
+  end
+  alias find detect
+  # builtin: true
+  # pure: true
+  def find_index(*args)
+  end
+  # builtin: true
+  # pure: true
+  def first(n=nil)
+  end
+  # builtin: true
+  # pure: true
+  def flat_map
+  end
+  # builtin: true
+  # pure: true
+  def grep(pattern)
+  end
+  # builtin: true
+  # pure: true
+  def group_by
+  end
+  # builtin: true
+  # pure: true
+  def include?(obj)
+  end
+  # builtin: true
+  # pure: true
+  def inject(*args)
+  end
+  # builtin: true
+  # pure: true
+  def map
+  end
+  # builtin: true
+  # pure: true
+  def max
+  end
+  # builtin: true
+  # pure: true
+  def max_by
+  end
+  alias member? include?
+  # builtin: true
+  # pure: true
+  def min
+  end
+  # builtin: true
+  # pure: true
+  def min_by
+  end
+  # builtin: true
+  # pure: true
+  def minmax
+  end
+  # builtin: true
+  # pure: true
+  def minmax_by
+  end
+  # builtin: true
+  # pure: true
+  def none?
+  end
+  # builtin: true
+  # pure: true
+  def one?
+  end
+  # builtin: true
+  # pure: true
+  def partition
+  end
+  alias reduce inject
+  # builtin: true
+  # pure: true
+  def reject
+  end
+  # builtin: true
+  # pure: true
+  def reverse_each(*args)
+  end
+  # builtin: true
+  # pure: true
+  def select()
+  end
+  alias find_all select
+  # builtin: true
+  # pure: true
+  def slice_before(first_arg=nil)
+  end
+  # builtin: true
+  # pure: true
+  def sort
+  end
+  # builtin: true
+  # pure: true
+  def sort_by
+  end
+  # builtin: true
+  # pure: true
+  def take(n)
+  end
+  # builtin: true
+  # pure: true
+  def take_while
+  end
+  # builtin: true
+  # pure: true
+  def to_a
+  end
+  # builtin: true
+  # pure: true
+  def zip(ary, *arys)
+  end
+end