functional-ruby 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe9f8b8bb0900055e86688c7995156bb89b5c0af
-  data.tar.gz: 794627125c2647c8e813b873c69f9be62bf3f206
+  metadata.gz: c56d810dbee5d5fb2e4b26daef765a75700d3e4f
+  data.tar.gz: e3e27de5c017c07eef5c9d78c590e73251fa98a9
 SHA512:
-  metadata.gz: b2e54bc22942b8e2be11ca19fe1c0bd393a1a868bff7f2717d5830efea7e048b53f574763352b778170fe6e46d76d7e42bd566200843595a97142a35572a7941
-  data.tar.gz: 21c78e069e28438cc55dcdd3f0a2dc0892a5f36236337cd42a28dc8597d04b33f9565a3a46b03ce8c405b3b7b80ade995e2cd4f24c01642335382eaaaf917fc6
+  metadata.gz: 84ba63762cb021ceb483e8f175a23c9ea11c12b5fa66764662670b9a688d4d2a0f15bb7baed3b8e2b2207a5b37613b62dc1c90c647bbb68176c0208b41c7cf8e
+  data.tar.gz: 7411ea271610c82bbf180e28797ab0e0a0795200d7c77f252e435e098acfe7224236fd59700b72fad726d4a03d43fd1829277f75b14dd8f7f8afd615a44410e0

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+## Current Release v1.1.0 (August 12, 2014)
+
+* A simple implementation of [tuple](http://en.wikipedia.org/wiki/Tuple), an
+  immutable, fixed-length list/array/vector-like data structure.
+* `FinalStruct`, a variation on Ruby's `OpenStruct` in which all fields are "final" (meaning
+  that new fields can be arbitrarily added but once set each field becomes immutable).
+* `FinalVar`, a thread safe object that holds a single value and is "final" (meaning
+  that the value can be set at most once after which it becomes immutable).
+
+### Previous Release v1.0.0 (July 30, 2014)
+
+* Protocol specifications inspired by Clojure [protocol](http://clojure.org/protocols),
+  Erlang [behavior](http://www.erlang.org/doc/design_principles/des_princ.html#id60128),
+  and Objective-C [protocol](https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/WorkingwithProtocols/WorkingwithProtocols.html)
+* Function overloading with Erlang-style [function](http://erlang.org/doc/reference_manual/functions.html)
+  [pattern matching](http://erlang.org/doc/reference_manual/patterns.html)
+* Simple, immutable data structures, such as *record* and *union*, inspired by
+  [Clojure](http://clojure.org/datatypes), [Erlang](http://www.erlang.org/doc/reference_manual/records.html),
+  and [others](http://en.wikipedia.org/wiki/Union_type)
+* `Either` and `Option` classes based on [Functional Java](http://functionaljava.org/) and [Haskell](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Either.html)
+* [Memoization](http://en.wikipedia.org/wiki/Memoization) of class methods based on Clojure [memoize](http://clojuredocs.org/clojure_core/clojure.core/memoize)
+* Lazy execution with a `Delay` class based on Clojure [delay](http://clojuredocs.org/clojure_core/clojure.core/delay)

data/README.md

@@ -1,5 +1,5 @@
 # Functional Ruby
-[![Gem Version](https://badge.fury.io/rb/functional-ruby.png)](http://badge.fury.io/rb/functional-ruby) [![Build Status](https://secure.travis-ci.org/jdantonio/functional-ruby.png)](https://travis-ci.org/jdantonio/functional-ruby?branch=master) [![Coverage Status](https://coveralls.io/repos/jdantonio/functional-ruby/badge.png)](https://coveralls.io/r/jdantonio/functional-ruby) [![Code Climate](https://codeclimate.com/github/jdantonio/functional-ruby.png)](https://codeclimate.com/github/jdantonio/functional-ruby) [![Inline docs](http://inch-ci.org/github/jdantonio/functional-ruby.png)](http://inch-ci.org/github/jdantonio/functional-ruby) [![Dependency Status](https://gemnasium.com/jdantonio/functional-ruby.png)](https://gemnasium.com/jdantonio/functional-ruby)
+[![Gem Version](https://badge.fury.io/rb/functional-ruby.svg)](http://badge.fury.io/rb/functional-ruby) [![Build Status](https://secure.travis-ci.org/jdantonio/functional-ruby.png)](https://travis-ci.org/jdantonio/functional-ruby?branch=master) [![Coverage Status](https://coveralls.io/repos/jdantonio/functional-ruby/badge.png)](https://coveralls.io/r/jdantonio/functional-ruby) [![Code Climate](https://codeclimate.com/github/jdantonio/functional-ruby.png)](https://codeclimate.com/github/jdantonio/functional-ruby) [![Inline docs](http://inch-ci.org/github/jdantonio/functional-ruby.png)](http://inch-ci.org/github/jdantonio/functional-ruby) [![Dependency Status](https://gemnasium.com/jdantonio/functional-ruby.png)](https://gemnasium.com/jdantonio/functional-ruby) [![License](http://img.shields.io/license/MIT.png?color=green)](http://opensource.org/licenses/MIT)
 
 **A gem for adding functional programming tools to Ruby. Inspired by [Erlang](http://www.erlang.org/),
 [Clojure](http://clojure.org/), and [Functional Java](http://functionaljava.org/).**
@@ -8,6 +8,8 @@
 focus. Version 1.0 is a cohesive set of utilities inspired by other languages
 but designed to work together in ways idiomatic to Ruby.*
 
+Please see the [changelog](https://github.com/jdantonio/functional-ruby/blob/master/CHANGELOG.md) for more information.
+
 ## Introduction
 
 Two things I love are [Ruby](http://www.ruby-lang.org/en/) and
@@ -38,15 +40,17 @@ Complete API documentation can be found at [Rubydoc.info](http://rubydoc.info/gi
 
 * Protocol specifications inspired by Clojure [protocol](http://clojure.org/protocols),
   Erlang [behavior](http://www.erlang.org/doc/design_principles/des_princ.html#id60128),
-  and Objective-C [protocol](https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/WorkingwithProtocols/WorkingwithProtocols.html)
+  and Objective-C [protocol](https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/WorkingwithProtocols/WorkingwithProtocols.html).
 * Function overloading with Erlang-style [function](http://erlang.org/doc/reference_manual/functions.html)
-  [pattern matching](http://erlang.org/doc/reference_manual/patterns.html)
-* Simple, immutable data structures, such as *record* and *union*, inspired by
+  [pattern matching](http://erlang.org/doc/reference_manual/patterns.html).
+* Simple, thread safe, immutable data structures, such as `Record`, `Union`, and `Tuple`, inspired by
   [Clojure](http://clojure.org/datatypes), [Erlang](http://www.erlang.org/doc/reference_manual/records.html),
-  and [others](http://en.wikipedia.org/wiki/Union_type)
-* `Either` and `Option` classes based on [Functional Java](http://functionaljava.org/) and [Haskell](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Either.html)
-* [Memoization](http://en.wikipedia.org/wiki/Memoization) of class methods based on Clojure [memoize](http://clojuredocs.org/clojure_core/clojure.core/memoize)
-* Lazy execution with a `Delay` class based on Clojure [delay](http://clojuredocs.org/clojure_core/clojure.core/delay)
+  and other functional languages.
+* Thread safe, immutable `Either` and `Option` classes based on [Functional Java](http://functionaljava.org/) and [Haskell](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Either.html).
+* [Memoization](http://en.wikipedia.org/wiki/Memoization) of class methods based on Clojure [memoize](http://clojuredocs.org/clojure_core/clojure.core/memoize).
+* Lazy execution with a `Delay` class based on Clojure [delay](http://clojuredocs.org/clojure_core/clojure.core/delay).
+* Thread safe data structures, such as `FinalStruct` and `FinalVar`, which can be written to at most once
+  before becoming immutable. Based on [Java's `final` keyword](http://en.wikipedia.org/wiki/Final_(Java)).
 
 ### Supported Ruby Versions
 
@@ -75,7 +79,7 @@ require 'functional'
 
 ## Examples
 
-Specifying a protocol:
+Specifying a [protocol](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/Protocol):
 
 ```ruby
 Functional::SpecifyProtocol(:Name) do
@@ -86,7 +90,27 @@ Functional::SpecifyProtocol(:Name) do
 end
 ```
 
-Pattern matching using protocols, type checking, and other options:
+Defining immutable [data structures](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/AbstractStruct) including
+[Either](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/Either),
+[Option](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/Option),
+[Union](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/Union) and
+[Record](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/Record)
+
+```ruby
+Name = Functional::Record.new(:first, :middle, :last, :suffix) do
+  mandatory :first, :last
+  default :first, 'J.'
+  default :last, 'Doe'
+end
+
+anon = Name.new #=> #<record Name :first=>"J.", :middle=>nil, :last=>"Doe", :suffix=>nil>
+matz = Name.new(first: 'Yukihiro', last: 'Matsumoto') #=> #<record Name :first=>"Yukihiro", :middle=>nil, :last=>"Matsumoto", :suffix=>nil>
+```
+
+[Pattern matching](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/PatternMatching)
+using [protocols](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/Protocol),
+[type](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/TypeCheck) checking,
+and other options:
 
 ```ruby
 class Foo
@@ -110,12 +134,8 @@ class Foo
     "Hello, #{name.first} #{name.last}!"
   }.when {|name| Satisfy?(:Name) }
 
-  defn(:greet, :male, _) { |name|
-    "Hello, Mr. #{name}!"
-  }
-
-  defn(:greet, :female, _) { |name|
-    "Hello, Ms. #{name}!"
+  defn(:greet, :doctor, _) { |name|
+    "Hello, Dr. #{name}!"
   }
 
   defn(:greet, nil, _) { |name|
@@ -128,7 +148,7 @@ class Foo
 end
 ```
 
-Memoization:
+Performance improvement of idempotent functions through [memoization](http://rubydoc.info/github/jdantonio/functional-ruby/master/Functional/Memo):
 
 ```ruby
 class Factors

data/doc/record.txt

@@ -124,6 +124,69 @@
 #   is created. Default values should be simple types like `String`, `Fixnum`,
 #   and `Boolean`. If complex operations need performed when setting default
 #   values the a `Class` should be used instead of a `Record`.
+#
+#   ### Why Declaration Differs from Ruby's Struct
+#
+#   Those familiar with Ruby's `Struct` class will notice one important
+#   difference when declaring a `Record`: the block passes to `new` cannot be
+#   used to define additional methods. When declaring a new class created from a
+#   Ruby `Struct` the block can perform any additional class definition that
+#   could be done had the class be defined normally. The excellent
+#   [Values](https://github.com/tcrayford/Values) supports this same behavior.
+#   `Record` does not allow additional class definitions during declaration for
+#   one simple reason: doing so violates two very important tenets of functional
+#   programming. Specifically, immutability and the separation of data from
+#   operations.
+#
+#   `Record` exists for the purpose of creating immutable objects. If additional
+#   instance methods were to be defined on a record class it would be possible
+#   to violate immutability. Not only could additional, mutable state be added
+#   to the class, but the existing immutable attributes could be overridden by
+#   mutable methods. The security of providing an immutable object would be
+#   completely shattered, thus defeating the original purpose of the record
+#   class. Of course it would be possible to allow this feature and trust the
+#   programmer to not violate the intended immutability of class, but opening
+#   `Record` to the *possibility* of immutability violation is unnecessary and
+#   unwise.
+#
+#   More important than the potential for immutability violations is the fact
+#   the adding additional methods to a record violates the principal of
+#   separating data from operations on that data. This is one of the core ideas
+#   in functional programming. Data is defined in pure structures that contain
+#   no behavior and operations on that data are provided by polymorphic
+#   functions. This may seem counterintuitive to object oriented programmers,
+#   but that is the nature of functional programming. Adding behavior to a
+#   record, even when that behavior does not violate immutability, is still
+#   anathema to functional programming, and it is why records in languages like
+#   Erlang and Clojure do not have functions defined within them.
+#
+#   Should additional methods need defined on a `Record` class, the appropriate
+#   practice is to declare the record class then declare another class which
+#   extends the record. The record class remains pure data and the subclass
+#   contains additional operations on that data.
+#
+#   ```ruby
+#   NameRecord = Functional::Record.new(:first, :middle, :last, :suffix) do
+#     mandatory :first, :last
+#   end
+#   
+#   class Name < NameRecord
+#     def full_name
+#       "#{first} #{last}"
+#     end
+#   
+#     def formal_name
+#       name = [first, middle, last].select{|s| ! s.to_s.empty?}.join(' ')
+#       suffix.to_s.empty? ? name : name + ", #{suffix}"
+#     end
+#   end
+#
+#   jerry = Name.new(first: 'Jerry', last: "D'Antonio")
+#   ted   = Name.new(first: 'Ted', middle: 'Theodore', last: 'Logan', suffix: 'Esq.')
+#
+#   jerry.formal_name #=> "Jerry D'Antonio"
+#   ted.formal_name   #=> "Ted Theodore Logan, Esq."
+#   ```
 #   
 #   ## Inspiration
 #   

data/doc/thread_safety.txt

@@ -6,3 +6,12 @@
 #     mutable references to mutable objects. This cannot be changed. The best
 #     practice it to only encapsulate immutable, frozen, or thread safe objects.
 #     Ultimately, thread safety is the responsibility of the programmer.
+#
+# @!macro [new] thread_safe_final_object
+#
+#   @note This is a write-once, read-many, thread safe object that can
+#     be used in concurrent systems. Thread safety guarantees *cannot* be made
+#     about objects contained *within* this object, however. Ruby variables are
+#     mutable references to mutable objects. This cannot be changed. The best
+#     practice it to only encapsulate immutable, frozen, or thread safe objects.
+#     Ultimately, thread safety is the responsibility of the programmer.

data/lib/functional.rb

@@ -1,13 +1,17 @@
 require 'functional/delay'
 require 'functional/either'
+require 'functional/final_struct'
+require 'functional/final_var'
 require 'functional/memo'
 require 'functional/option'
 require 'functional/pattern_matching'
 require 'functional/protocol'
 require 'functional/protocol_info'
 require 'functional/record'
+require 'functional/tuple'
 require 'functional/type_check'
 require 'functional/union'
+require 'functional/value_struct'
 require 'functional/version'
 
 Functional::SpecifyProtocol(:Disposition) do

data/lib/functional/abstract_struct.rb

@@ -11,6 +11,8 @@ end
 module Functional
 
   # An abstract base class for immutable struct classes.
+  #
+  # @since 1.0.0
   module AbstractStruct
 
     # @return [Array] the values of all record fields in order, frozen
@@ -47,7 +49,7 @@ module Functional
     # field values (according to `Object#==`).
     #
     # @param [Object] other the other record to compare for equality
-    # @return [Booleab] true when equal else false
+    # @return [Boolean] true when equal else false
     def eql?(other)
       self.class == other.class && self.to_h == other.to_h
     end
@@ -55,7 +57,7 @@ module Functional
 
     # @!macro [attach] inspect_method
     #
-    #   Describe the contents of this record in a string. Will include the name of the
+    #   Describe the contents of this struct in a string. Will include the name of the
     #   record class, all fields, and all values.
     #
     #   @return [String] the class and contents of this record

data/lib/functional/delay.rb

@@ -17,6 +17,8 @@ module Functional
   #
   # @see http://clojuredocs.org/clojure_core/clojure.core/delay Clojure delay
   #
+  # @since 1.0.0
+  #
   # @!macro thread_safe_immutable_object
   class Delay
 

data/lib/functional/either.rb

@@ -77,6 +77,8 @@ module Functional
   # @see https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Either.html Haskell Data.Either
   # @see http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Obligation.html Concurrent Ruby
   #
+  # @since 1.0.0
+  #
   # @!macro thread_safe_immutable_object
   class Either
     include AbstractStruct

data/lib/functional/final_struct.rb

@@ -0,0 +1,231 @@
+require_relative 'final_var'
+require 'thread'
+
+module Functional
+
+  # A variation on Ruby's `OpenStruct` in which all fields are "final" (meaning
+  # that new fields can be arbitrarily added to a `FinalStruct` object but once
+  # set each field becomes immutable). Additionally, predicate methods exist for
+  # all fields and these predicates indicate if the field has been set.
+  #
+  # There are two ways to initialize a `FinalStruct`: with zero arguments or
+  # with a `Hash` (or any other object that implements a `to_h` method). The
+  # only difference in behavior is that a `FinalStruct` initialized with a
+  # hash will pre-define and pre-populate attributes named for the hash keys
+  # and with values corresponding to the hash values.
+  #
+  # @example Instanciation With No Fields
+  #   bucket = Functional::FinalStruct.new
+  #
+  #   bucket.foo      #=> nil
+  #   bucket.foo?     #=> false
+  #
+  #   bucket.foo = 42 #=> 42
+  #   bucket.foo      #=> 42
+  #   bucket.foo?     #=> true
+  #
+  #   bucket.foo = 42 #=> Functional::FinalityError: final accessor 'bar' has already been set
+  #
+  # @example Instanciation With a Hash
+  #   name = Functional::FinalStruct.new(first: 'Douglas', last: 'Adams')
+  #
+  #   name.first           #=> 'Douglas'
+  #   name.last            #=> 'Adams'
+  #   name.first?          #=> true
+  #   name.last?           #=> true
+  #
+  #   name.middle #=> nil
+  #   name.middle?         #=> false
+  #   name.middle = 'Noel' #=> 'Noel'
+  #   name.middle?         #=> true
+  #
+  #   name.first = 'Sam'   #=> Functional::FinalityError: final accessor 'first' has already been set
+  #
+  # @since 1.1.0
+  #
+  # @see Functional::FinalVar
+  # @see http://www.ruby-doc.org/stdlib-2.1.2/libdoc/ostruct/rdoc/OpenStruct.html
+  # @see http://en.wikipedia.org/wiki/Final_(Java) Java `final` keyword
+  #
+  # @!macro thread_safe_final_object
+  class FinalStruct
+
+    # Creates a new `FinalStruct` object. By default, the resulting `FinalStruct`
+    # object will have no attributes. The optional hash, if given, will generate
+    # attributes and values (can be a `Hash` or any object with a `to_h` method).
+    #
+    # @param [Hash] attributes the field/value pairs to set on creation
+    def initialize(attributes = {})
+      raise ArgumentError.new('attributes must be given as a hash or not at all') unless attributes.respond_to?(:to_h)
+      @mutex = Mutex.new
+      @attribute_hash = {}
+      attributes.to_h.each_pair do |field, value|
+        set_attribute(field, value)
+      end
+    end
+
+    # @!macro [attach] final_struct_get_method
+    #
+    #   Get the value of the given field.
+    #
+    #   @param [Symbol] field the field to retrieve the value for
+    #   @return [Object] the value of the field is set else nil
+    def get(field)
+      @mutex.synchronize {
+        get_attribute(field)
+      }
+    end
+    alias_method :[], :get
+
+    # @!macro [attach] final_struct_set_method
+    #
+    #   Set the value of the give field to the given value.
+    #
+    #   It is a logical error to attempt to set a `final` field more than once, as this
+    #   violates the concept of finality. Calling the method a second or subsequent time
+    #   for a given field will result in an exception being raised.
+    #
+    #   @param [Symbol] field the field to set the value for
+    #   @param [Object] value the value to set the field to
+    #   @return [Object] the final value of the given field
+    #
+    # @raise [Functional::FinalityError] if the given field has already been set
+    def set(field, value)
+      @mutex.synchronize {
+        if attribute_has_been_set?(field)
+          raise FinalityError.new("final accessor '#{field}' has already been set")
+        else
+          set_attribute(field, value)
+        end
+      }
+    end
+    alias_method :[]=, :set
+
+    # @!macro [attach] final_struct_set_predicate
+    #
+    #   Check the internal hash to unambiguously verify that the given
+    #   attribute has been set.
+    #
+    #   @param [Symbol] field the field to get the value for
+    #   @return [Boolean] true if the field has been set else false
+    def set?(field)
+      @mutex.synchronize {
+        attribute_has_been_set?(field)
+      }
+    end
+
+    # Get the current value of the given field if already set else set the value of
+    # the given field to the given value.
+    #
+    # @param [Symbol] field the field to get or set the value for
+    # @param [Object] value the value to set the field to when not previously set
+    # @return [Object] the final value of the given field
+    def get_or_set(field, value)
+      @mutex.synchronize {
+        attribute_has_been_set?(field) ? get_attribute(field) : set_attribute(field, value)
+      }
+    end
+
+    # Get the current value of the given field if already set else return the given
+    # default value.
+    #
+    # @param [Symbol] field the field to get the value for
+    # @param [Object] default the value to return if the field has not been set
+    # @return [Object] the value of the given field else the given default value
+    def fetch(field, default)
+      @mutex.synchronize {
+        attribute_has_been_set?(field) ? get_attribute(field) : default
+      }
+    end
+
+    # Calls the block once for each attribute, passing the key/value pair as parameters.
+    # If no block is given, an enumerator is returned instead.
+    #
+    # @yieldparam [Symbol] field the struct field for the current iteration
+    # @yieldparam [Object] value the value of the current field
+    #
+    # @return [Enumerable] when no block is given
+    def each_pair
+      return enum_for(:each_pair) unless block_given?
+      @mutex.synchronize {
+        @attribute_hash.each do |field, value|
+          yield(field, value)
+        end
+      }
+    end
+
+    # Converts the `FinalStruct` to a `Hash` with keys representing each attribute
+    # (as symbols) and their corresponding values.
+    # 
+    # @return [Hash] a `Hash` representing this struct
+    def to_h
+      @mutex.synchronize {
+        @attribute_hash.dup
+      }
+    end
+
+    # Compares this object and other for equality. A `FinalStruct` is `eql?` to
+    # other when other is a `FinalStruct` and the two objects have identical
+    # fields and values.
+    #
+    # @param [Object] other the other record to compare for equality
+    # @return [Boolean] true when equal else false
+    def eql?(other)
+      other.is_a?(self.class) && to_h == other.to_h
+    end
+    alias_method :==, :eql?
+
+    # Describe the contents of this object in a string.
+    #
+    # @return [String] the string representation of this object
+    #
+    # @!visibility private
+    def inspect
+      state = to_h.to_s.gsub(/^{/, '').gsub(/}$/, '')
+      "#<#{self.class} #{state}>"
+    end
+    alias_method :to_s, :inspect
+
+    protected
+
+    # @!macro final_struct_get_method
+    # @!visibility private
+    def get_attribute(field)
+      @attribute_hash[field.to_sym]
+    end
+
+    # @!macro final_struct_set_method
+    # @!visibility private
+    def set_attribute(field, value)
+      @attribute_hash[field.to_sym] = value
+    end
+
+    # @!macro final_struct_set_predicate
+    # @!visibility private
+    def attribute_has_been_set?(field)
+      @attribute_hash.has_key?(field.to_sym)
+    end
+
+    # Check the method name and args for signatures matching potential
+    # final attribute reader, writer, and predicate methods. If the signature
+    # matches a reader or predicate, treat the attribute as unset. If the
+    # signature matches a writer, attempt to set the new attribute.
+    #
+    # @param [Symbol] symbol the name of the called function
+    # @param [Array] args zero or more arguments
+    # @return [Object] the result of the proxied method or the `super` call
+    #
+    # @!visibility private
+    def method_missing(symbol, *args)
+      if args.length == 1 && (match = /([^=]+)=$/.match(symbol))
+        set(match[1], args.first)
+      elsif args.length == 0 && (match = /([^\?]+)\?$/.match(symbol))
+        set?(match[1])
+      elsif args.length == 0
+        get(symbol)
+      else
+        super
+      end
+    end
+  end
+end