syntheticore-perlize 0.1.1

data/README.textile

@@ -0,0 +1,70 @@
+h3. The Ruby perlizer
+
+This module implements some of the cooler features 
+of Perl6 in Ruby, like topics, junctions and hyperoperators.
+Extremely hackish currently, needs to be generalized
+somewhat in the future.
+
+Currently you can do the following things:
+
+
+h3. Topicalization
+
+<pre>
+<code>
+    doubles = [1,2,3].map{ $__ * 2 }
+</code>
+</pre>
+
+The topic variable works with most iterators and can also be
+explicitly set using
+<pre>
+<code>
+    given object_with_long_name do
+        $__.foo
+        $__.bar
+        $__.foobar
+    end
+</code>
+</pre>
+
+
+h3. Junctions
+
+A junction is the composition of multiple values into one,
+the individual values being bound by a logical relation.
+
+<pre>
+<code>
+    5 < 2|4|6   #=> true
+    5 < 2&4&6   #=> false
+    5 == 1|5|9  #=> true
+    2|3 < 3&4&5 #=> true
+</code>
+</pre>
+
+Junctions can also be created using the all() and any() methods
+from several arguments. Iterating through a junctions does
+that in parallel.
+<pre>
+<code>
+    all(1,2,3,4,5).each{ puts $__ }
+    #=>
+    3
+    5
+    2
+    1
+    4
+</code>
+</pre>
+
+
+h3. Hyperoperators
+
+<pre>
+<code>
+    sum = [1,2,3]._(:+)    #=> 6
+    fact = (1..9)._(:*)    #=> 362880
+    [1,2,3]._(:+, [3,2,1]) #=> [4,4,4]
+</code>
+</pre>

data/perlize.rb

@@ -0,0 +1,216 @@
+#!/usr/bin/env ruby
+#
+#  Created by Björn Breitgoff on 17.7.2008.
+#
+# Implements some of the cooler features of Perl6
+# in Ruby, like topics, junctions and hyperoperators.
+# Extremely hackish currently, needs to be generalized
+# somewhat in the future
+
+
+
+###------------ Topicalization ------------###
+
+class Module
+  def _topicalize_ *meths
+    for meth in meths
+      class_eval "
+        alias __#{meth} #{meth}
+        def #{meth}
+          self.__#{meth} do |arg|
+            $_2 = arg if $_1
+            $_1 = arg if $_1.nil?
+            $__ = [$_1, $_2].compact.last
+            return_value = yield *arg
+            $_1 = nil if $_2.nil?
+            $_2 = nil
+            $__ = [$_1, $_2].compact.last
+            return_value
+          end
+        end
+      "
+    end
+  end
+end
+
+def given o
+  $__ = o
+  yield
+end
+
+class Array
+  _topicalize_ *%w(each map select sort_by any? all?)
+end
+
+class Range
+  _topicalize_ *%w(each map select sort_by any? all?)
+end
+
+class Integer
+  _topicalize_ *%w(times step upto downto)
+end
+
+
+
+
+###------------ Hyper and reduction operators ------------###
+
+module Enumerable
+  def _ op, enum=nil
+    if enum
+      zip(enum).map{|i,j| i && j ? eval("#{i}.#{op} #{j}") : nil }.compact
+    else
+      eval "inject{|a,b| a.#{op} b }"
+    end
+  end
+end
+
+
+
+
+###------------ Junctions ------------###
+
+class Junction
+  attr_reader :operator, :objects
+  def initialize( operator, *objs )
+    @operator = operator
+    @objects = objs
+  end
+  
+  def & o
+    raise "You cannot mix junction types" if @operator == :or or (o.is_a?(Junction) and o.operator != @operator)
+    @objects << (o.is_a?(Junction) ? o.objects : o)
+    @objects.flatten!
+    self
+  end
+  
+  def | o
+    raise "You cannot mix junction types" if @operator == :and or (o.is_a?(Junction) and o.operator != @operator)
+    @objects << (o.is_a?(Junction) ? o.objects : o)
+    @objects.flatten!
+    self
+  end
+  
+  def method_missing( meth, *args )
+    Junction.define_operator meth
+    send meth, *args
+  end
+  
+  # XXX define as method_missing
+  def Junction.define_operator op
+    class_eval "
+      def #{op}( arg, direction=:normal )
+        if arg.is_a? Junction
+          case @operator
+          when :and
+            @objects.all?{ $__.#{op} arg }
+          when :or
+            @objects.any?{ $__.#{op} arg }
+          end
+        else
+          value = (@operator == :and) 
+          for obj in @objects
+            case @operator
+            when :and
+              if direction == :normal
+                value = (value and (obj.#{op} arg))
+              else
+                value = (value and (arg.#{op} obj))
+              end
+            when :or
+              if direction == :normal
+                value = (value or (obj.#{op} arg))
+              else
+                value = (value or (arg.#{op} obj))
+              end
+              return value if value
+            end
+          end
+          return value
+        end
+      end
+    "
+  end
+  define_operator "=="
+  define_operator "<"
+  define_operator ">"
+
+  def each
+    threads = []
+    @objects.each do |obj|
+      threads << Thread.start(obj){|o| yield o }
+    end
+    threads.each{|t| t.join }
+    self
+  end
+  _topicalize_ 'each'
+  
+  def to_s
+    "Junction: " + @objects.join(" #{@operator.to_s} ")
+  end
+end
+
+
+class Module
+  def _junctionize_ meths=nil
+    class_eval "
+    def & o
+      Junction.new( :and, self, o )
+    end
+
+    def | o
+      Junction.new( :or, self, o )
+    end
+    "
+    suitable_methods = meths || %w(== < > <= >=)
+    methods = public_instance_methods & suitable_methods
+    #module_methods = public_methods & suitable_methods
+    methods.each{ define_junction_method $__ }
+    #module_methods.each{ define_junction_method( $__, :class ) }
+  end
+      
+  def define_junction_method( meth, type=:instance )
+    unless ["__id__", "__send__"].any?{ $__ == meth }
+      # convert operators to their ascii value for aliasing
+      internal = '__' + meth.gsub(/[~@^+-=>*<%&|\[\]]/){ $~[0][0].to_s }
+      class_eval "
+      alias :___#{internal} :#{meth}
+      def #{(type == :class) ? 'self.' : ''}#{meth} o
+        if o.is_a? Junction
+          o.#{meth}( self, :inverse )
+        else
+          #{type == :class ? (self.class.to_s + '::') : 'self.'}___#{internal} o
+        end
+      end
+      "
+    end
+  end
+end
+
+def all( *objs, &block )
+  j = Junction.new( :and, *objs )
+  j.each{|o| yield o } if block_given?
+  j
+end
+
+def any( *objs, &block )
+  j = Junction.new( :or, *objs )
+  j.each{|o| yield o }  if block_given?
+  j
+end
+
+class Fixnum
+  _junctionize_
+end
+
+class Bignum
+  _junctionize_
+end
+
+class Float
+  _junctionize_
+end
+
+class String
+  _junctionize_
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+name: syntheticore-perlize
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- "Bj\xC3\xB6rn Breitgoff"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-28 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Some Perl6 magic for ruby
+email: breidibreit@web.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.textile
+- perlize.rb
+has_rdoc: false
+homepage: http://github.com/syntheticore/perlize
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Some Perl6 magic for ruby
+test_files: []
+