syntheticore-perlize 0.1.4 → 0.1.5

data/README.textile

@@ -1,9 +1,8 @@
 h3. The Ruby perlizer
 
-This module implements some of the coolest features 
-of Perl6 in Ruby, like topics, junctions, lazy lists and hyperoperators.
-Extremely hackish currently, needs to be generalized
-somewhat in the future.
+ Implements some of the coolest features of Perl6 in Ruby.
+ Extremely hackish currently, needs to be generalized
+ somewhat in the future
 
 Currently you can do the following things:
 
@@ -16,17 +15,8 @@ h3. Topicalization
 </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>
+The topic variable works with most common iterators.
+Topicalization is unfortunately not thread-safe!
 
 
 h3. Junctions
@@ -48,13 +38,9 @@ from several arguments. Iterating through a junctions does
 that in parallel.
 <pre>
 <code>
-    all(1,2,3,4,5).each{ puts $__ }
+    all(1,2,3,4,5).each{|n| print n }
     # prints:
-    3
-    5
-    2
-    1
-    4
+    35214
 </code>
 </pre>
 
@@ -77,12 +63,56 @@ You can force the evaluation of all elements using the eager method.
 </pre>
 
 
-h3. Hyperoperators
+h3. Other niceties
+
+In Ruby, I often write code like this
+<pre>
+<code>
+    old_dog_names = people.map{|p| p.parents }.flatten.map{|p| p.dogs }.flatten.map{|d| d.name }.uniq
+</code>
+</pre>
+which is alot of work to type. In Ruby 1.9 and 1.8.7 you can write:
+<pre>
+<code>
+    old_dog_names = people.map(&:parents).flatten.map(&:dogs).flatten.map(&:name).uniq
+</code>
+</pre>
+which is already pretty beautifull. Perl6 even reserves extra syntax for that common task and lets you write
+<pre>
+<code>
+    my @old_dog_names = (@people>>.parents>>.dogs>>.name).uniq
+</code>
+</pre>
+instead. I came up with this in Ruby:
+<pre>
+<code>
+    old_dog_names = (people>:parents>:dogs>:names).uniq
+</code>
+</pre>
+Pretty close I think! When called with another enumerable as argument, this works like a hyperoperator
+<pre>
+<code>
+    [1,2,3]>:+, [3,2,1]  #=> [4,4,4]
+</code>
+</pre>
 
+Another common situation is this:
 <pre>
 <code>
-    sum = [1,2,3]._(:+)    #=> 6
-    fact = (1..9)._(:*)    #=> 362880
-    [1,2,3]._(:+, [3,2,1]) #=> [4,4,4]
+    @var.foo.bar if @var and @var.foo
 </code>
 </pre>
+where we call a method on a particular attribute only if it is defined. We can now simply write:
+<pre>
+<code>
+    @var>>:foo>>:bar
+</code>
+</pre>
+This is somewhat like
+<pre>
+<code>
+    $var //.meth
+</code>
+</pre>
+in Perl6.
+

data/perlize.rb

@@ -2,14 +2,63 @@
 #
 #  Created by Björn Breitgoff on 17.7.2008.
 #
-# Implements some of the coolest features of Perl6
-# in Ruby, like topics, junctions and hyperoperators.
+# Implements some of the coolest features of Perl6 in Ruby
 # Extremely hackish currently, needs to be generalized
 # somewhat in the future
 
 
 
-###------------ Lazy lists ------------###
+# Topicalization
+# doubles = [1,2,3].map{ $__ * 2 }
+
+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 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
+
+
+
+# Lazy list
+# results = [1,2,3].lazy.map{ $__ * 2 }.map{ $__ - 1 }
+# results[2]      #=> 5 
+# results.eager   #=> [1,3,5]
+# The results array is instantly available, without ever running the map methods.
+# Only when you request one of its values, these are actually calculated.
+# You can force the evaluation of all elements using the eager method.
 
 class Array
   def lazy
@@ -63,67 +112,70 @@ end
 
 
 
+# Chained, flattening attribute mapping with auto-singularization
+# old_dog_names = (people>:parents>:parents>:dogs>:names).uniq
+# When called with another enumerable as argument, this works like a hyperoperator
 
-###------------ 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
-      "
+module Enumerable
+  def > meth, enum=nil
+    return [] if empty?
+    unless first.respond_to? meth
+      meth = meth.to_s
+      meth[-1] = ""
+      meth = meth.to_sym
+    end
+    if enum
+      zip(enum).map{|i,j| i && j ? i.send(meth, j) : nil }.compact
+    else
+      map(&meth).flatten
     end
   end
 end
 
-def given o
-  $__ = o
-  yield
-end
 
-class Array
-  _topicalize_ *%w(each map map! select sort_by any? all?)
-end
 
-class Range
-  _topicalize_ *%w(each map select sort_by any? all?)
-end
+# obj>>:method means: call method unless obj is nil
+# this is somewhat like //.meth in Perl6
 
-class Integer
-  _topicalize_ *%w(times step upto downto)
+class Object
+  def >> m, *args
+    send( m, *args ) unless nil?
+  end
 end
 
 
 
+# has declares attributes of a class
+# It also creates a default initialize method that takes values
+# in the same order as the attributes declared
 
-###------------ 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
+class Module
+  def has *methods
+    attr_accessor *methods
+    class_eval "
+      def init(*args)
+        raise ArgumentError unless args.size == #{methods.size}
+        #{methods.inspect}.zip args do |m,a|
+          send( m.to_s + '=', a )
+        end
+      end
+      
+      def initialize(*args)
+        init(*args)
+      end
+    "
   end
 end
 
 
 
-
-###------------ Junctions ------------###
+# A junction is the composition of multiple values into one,
+# the individual values being bound by a logical relation.
+#    5 < 2|4|6   #=> true
+#    5 < 2&4&6   #=> false
+#    5 == 1|5|9  #=> true
+#    2|3 < 3&4&5 #=> true
+# Call _junctionize_ in your class definitions to make your own classes work in Junctions
 
 class Junction
   attr_reader :operator, :objects

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: syntheticore-perlize
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - "Bj\xC3\xB6rn Breitgoff"
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-12 00:00:00 -08:00
+date: 2009-09-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: Some Perl6 magic for ruby
+description: Some Perl6-inspired magic for ruby
 email: breidibreit@web.de
 executables: []
 
@@ -49,6 +49,6 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Some Perl6 magic for ruby
+summary: Some Perl6-inspired magic for ruby
 test_files: []