rbl 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0c45704ab8c82b9f4d22ff2b09e893637268825
-  data.tar.gz: 6f92595032263d7d955814b7f781818edfabdd8b
+  metadata.gz: 2f79f3d05ec02a277eb9cc2b52e66cfb0bc167df
+  data.tar.gz: a1e2bd7b861f7bddd40b47092e508d542b78a89a
 SHA512:
-  metadata.gz: 4a216b4f765b5755b3c8b7f01d7079e9d547219c70e0434155114e2c01dccd9d57e21273d99ea121765a9d6137b5ca31219ace852e12aa654edc6fcb1d863568
-  data.tar.gz: 19d1a9786dae75dcb96180a4ac483b5470f3f4f3fcc3c4884139e2884d21af774330ff4fffe9c1c1582f212cd781b77f7cb2eceed895996d8ceec653f5d28baf
+  metadata.gz: e5517a472833aad9bd8670c0aceb5b7fac368bf5cc0c96a12d1eed9352d563bd6599fcdceb006e4d6565567dfc1bd1a761ed395758b5448b3285b28e7b82aa51
+  data.tar.gz: ca25909f9d314a751ce37b51c5b82ca61e9cb26706bc68d60dddf7af896d8fb0c09ff3c2cbf07301397eae7cd1239024929c526b5a30225ff4b3a5b31b9ae6b3

data/README.md

@@ -36,7 +36,177 @@ I think I was right. Check it out, everyone -- you can write your Ruby scripts i
 
 ## Examples
 
-_TODO_
+### It's basically Clojure
+
+Many of the affordances of the Clojure standard library are implemented as part
+of the `rbl.core` namespace, which is included by default:
+
+```clojure
+user> (prn 'oh :hello "hi" 1 2.3 '(abc def) ['g ()] '{:h ijk})
+oh :hello "hi" 1 2.3 (abc def) [g ()] {:h ijk}
+nil
+
+user> (take 20 (map inc (reverse (range 100))))
+(101 100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82)
+```
+
+### Module/Class members
+
+Members of Ruby modules and classes may be accessed in a familiar way, by appending `::` to the module or class:
+
+```clojure
+user> Kernel::ARGV
+[]
+
+user> Encoding::Converter::CR_NEWLINE_DECORATOR
+8192
+
+user> File::SEPARATOR
+"/"
+```
+
+### Instance methods
+
+Instance methods are called like Lisp functions. The reader will recognize any symbol that starts with `.` as an instance method, and send it as a message to the second element in the S-expression.
+
+For example, `(.+ 1 2)` in RubyLisp is equivalent to `1.send(:+, 2)` in Ruby.
+
+```clojure
+user> (def f (File::open "/tmp/ugh.txt"))
+#<File:/tmp/ugh.txt>
+
+user> (.methods f)
+[:size :path :truncate :lstat :atime :mtime :ctime :birthtime :chmod :chown ...
+:! :== :!= :__send__ :equal? :instance_eval :instance_exec :__id__]
+
+user> (.readbyte f)
+66
+
+user> (.size f)
+365
+```
+
+### Immutable lists
+
+The `list` function and `quote` form (e.g. `'(1 2 3)`) create immutable lists from the [Hamster][hamster] library:
+
+```clojure
+user> (class (list 1 2 3))
+Hamster::Cons
+
+user> (class '(abc def))
+Hamster::Cons
+
+user> (cons 'foo (quote (bar baz)))
+(foo bar baz)
+```
+
+### Immutable vectors
+
+Similarly, the `vector` and `vec` functions, as well as the square bracket literal form, create immutable vectors:
+
+```clojure
+user> (vector 1 2 3)
+[1 2 3]
+
+user> (vec (list 1 2 3))
+[1 2 3]
+
+user> (= [1 2 3] (vector 1 2 3))
+true
+
+user> (class [1 2 3])
+Hamster::Vector
+```
+
+### Immutable maps
+
+The `hash-map` function or the curly brace literal form can be used to create an immutable map:
+
+```clojure
+user> (map? (hash-map 'a 1 'b 2 'c 3))
+true
+
+user> {:a 1 "b" 2 'C 3}
+{:a 1, C 3, "b" 2}
+```
+
+### Keywords (a.k.a. Symbols)
+
+A keyword (in Clojure and therefore RubyLisp parlance) begins with a `:`. In Ruby, this data type is called, somewhat confusingly, a Symbol.
+
+```clojure
+user> (class :floop)
+Symbol
+
+user> (= :snoob (.to_sym "snoob"))
+true
+```
+
+RubyLisp monkey-patches the Symbol class to make it behave like a Clojure keyword; you can call it like a function in order to retrieve a value from a hash map:
+
+```clojure
+user> (def barbara {:age 7 :species "greyhound"})
+{:age 7, :species "greyhound"}
+
+user> (:species barbara)
+"greyhound"
+```
+
+### Instance variables
+
+But that's not all -- you can also use keywords to get the value of an instance variable:
+
+```clojure
+; FIXME: This is a contrived example because it is not yet possible to easily
+define a class in RubyLisp.
+
+; rbl.core/=@ is provided as a convenient way to set instance variables on any
+object... even a string!
+user> (def s "my string")
+"my string"
+
+user> (=@ s :object_level 9001)
+9001
+
+; instance variables can then be retrieved by using a keyword as a function
+user> (:object_level s)
+9001
+```
+
+The above example is a little nonsensical (although a testament to the whimsy
+of Ruby), but the pair of `=@` and keyword-used-as-a-function will be more
+useful once there is a convenient way to define classes in RubyLisp.
+
+### Mutable arrays and hashes
+
+You can still use Ruby's mutable data structures via inter-op, if you insist:
+
+```clojure
+user> (def a (.dup (.to_a [1 2 3 4 5])))
+[1 2 3 4 5]
+
+user> (class a)
+Array
+
+user> (.<< a 6)
+[1 2 3 4 5 6]
+
+user> a
+[1 2 3 4 5 6]
+
+user> (def h (.to_h {}))
+{}
+
+user> (class h)
+Hash
+
+user> (.merge! h {:a 3})
+{:a 3}
+
+user> h
+{:a 3}
+```
 
 ## Installation
 

data/lib/rubylisp/evaluator.rb

@@ -196,7 +196,7 @@ module RubyLisp
           fn, *args = input.value
           quoted_form = args[0]
 
-          if [RubyLisp::List, RubyLisp::Vector].member? quoted_form.class
+          if [RubyLisp::HashMap, RubyLisp::List, RubyLisp::Vector].member? quoted_form.class
             quoted_form.quote.value
           else
             quoted_form.quote

data/lib/rubylisp/printer.rb

@@ -18,11 +18,10 @@ module RubyLisp
           pr_str x.to_hash
         when Hamster::List
           "(#{x.map {|item| pr_str(item)}.join(' ')})"
-        when RubyLisp::Keyword
-          ":#{x.value}"
         when RubyLisp::List
           "(#{x.value.map {|item| pr_str(item)}.join(' ')})"
-        when RubyLisp::Symbol, RubyLisp::Int, RubyLisp::Float
+        when RubyLisp::Symbol, RubyLisp::String, RubyLisp::Int, RubyLisp::Float,
+             RubyLisp::Boolean, RubyLisp::Keyword
           x.value
         else
           x.inspect

data/lib/rubylisp/types.rb

@@ -5,6 +5,10 @@ require 'hamster/vector'
 
 # Monkey-patch Ruby symbols to act more like Clojure keywords
 class Symbol
+	def name
+		to_s[1..-1]
+	end
+
   def to_s
     inspect
   end
@@ -13,7 +17,7 @@ class Symbol
     if [Hash, Hamster::Hash].member? target.class
       target[self]
     else
-      target.instance_variable_get "@#{self.to_s}".to_sym
+      target.instance_variable_get "@#{name}".to_sym
     end
   end
 end
@@ -33,6 +37,12 @@ module Hamster
     end
   end
 
+  class Hash
+    def to_s
+      "{#{to_hash.map {|k, v| "#{k} #{v}"}.join ", "}}"
+    end
+  end
+
   class Vector
     def to_s
       "[#{join " "}]"
@@ -81,6 +91,18 @@ module RubyLisp
         @value = Hamster::Hash[seq.each_slice(2).to_a]
       end
     end
+
+    def quote
+      @value.each {|k, v| k.quote; v.quote}
+      @quoted = true
+      self
+    end
+
+    def unquote
+      @value.each {|k, v| k.unquote; v.unquote}
+      @quoted = false
+      self
+    end
   end
 
   class List < Value

data/lib/rubylisp/version.rb

@@ -1,3 +1,3 @@
 module RubyLisp
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/rubylisp/core.rbl

@@ -118,11 +118,18 @@
   (fn nil? [x]
     (= nil x)))
 
+(def string?
+  (fn string? [x]
+    (.is_a? x Kernel::String)))
+
+;; TODO: implement & use cond
 (def count
   (fn count [x]
     (if (nil? x)
       0
-      (.count x))))
+      (if (string? x)
+        (.count (seq x))
+        (.count x)))))
 
 (def empty?
   (fn empty? [coll]
@@ -140,9 +147,25 @@
   (fn list? [x]
     (.is_a? x Hamster::List)))
 
-(def string?
-  (fn string? [x]
-    (.is_a? x Kernel::String)))
+(def vector
+  (fn vector [& args]
+    (Hamster::Vector::new args)))
+
+(def vector?
+  (fn vector? [x]
+    (.is_a? x Hamster::Vector)))
+
+(def vec
+  (fn vec [coll]
+    (Hamster::Vector::new coll)))
+
+(def hash-map
+	(fn hash-map [& args]
+    (Hamster::Hash::new (.to_h (.each_slice args 2)))))
+
+(def map?
+  (fn map? [x]
+    (.is_a? x Hamster::Hash)))
 
 (def seq
   (fn seq [x]
@@ -204,12 +227,18 @@
       (apply Hamster::repeat args)
       (apply Hamster::replicate args))))
 
-;; STRINGS
+;; STRINGS & KEYWORDS
 
 (def str
   (fn str [& args]
     (.join (map .to_s args))))
 
+(def name
+  (fn name [x]
+    (if (string? x)
+      x
+      (.name x))))
+
 ;; I/O
 
 (def pr-str
@@ -237,7 +266,7 @@
 
 (def =@
   (fn =@ [obj kw value]
-    (.instance_variable_set obj (.to_sym (+ "@" (.to_s kw))) value)))
+    (.instance_variable_set obj (.to_sym (+ "@" (name kw))) value)))
 
 (def class
   (fn class [x]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbl
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Dave Yarwood