lab42_core 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16682f25db174dc49c05db95880ad4dbdffb08a6
-  data.tar.gz: 9303958cffdf2f045054a1f3860de6f509213b43
+  metadata.gz: 50b79fb53cb3eabf40d9a75db01d945d338b5dfc
+  data.tar.gz: 60df674bd40c480f1dbfd62ac5c11b0a3bf5a7ba
 SHA512:
-  metadata.gz: 4cdfb75fd68d03b62a023b6064c5e63d52ea69392e514df65eaaaa8a2ee2f90a4c18479b7db795013ec9c5d0b7d83c6cefdeab117561e2cf89f2105b5bdf6fe7
-  data.tar.gz: b814d0a775141a045f84b810d7cc37d8cf5159c39e73eb42886a7b74cf6aaf9adcff8b8816302d791ca0b794071ac8b13feebc2dd6cc488c3ed5653de1d8c82a
+  metadata.gz: 65fa1b525bee1585344538b8d1b86fcc657d62803c1ee7afd74f36e0ae5c26cdf1761bc617aac5679f856315a8ce746cd5ca3b893cc72225548e1114b5cb5e64
+  data.tar.gz: 169ec69933e737e28809724d47d1e71816f6a927fb3649f76538310c1bd0ada7869fad22f726f29f6fe9c2e762ec791e1dfb60e95f41d622bcfeb969abbc4bb0

data/README.md

@@ -1,6 +1,5 @@
 
 
-
 # lab42\_core
 
 
@@ -11,6 +10,107 @@
 
 Simple Ruby Core Module Extensions (for more see lab42\_more)
 
+## Programming Paradigms
+
+### Memoization and Lazy Attributes
+
+#### Memoization
+
+is a, slightly forgotten, programming technique protecting against double calcultions.
+
+This became extremly useful with [Dynamic Programming](https://en.wikipedia.org/wiki/Dynamic_programming#Dijkstra.27s_algorithm_for_the_shortest_path_problem) .
+
+A much more simle example is allowing us to express and implement the [Fibonacci Sequence](https://en.wikipedia.org/wiki/Dynamic_programming#Fibonacci_sequence) in the same, some might say naïve, way.
+
+Compared to the explicit memoization as shown in the Wikipedia article, which would read as follows in Ruby
+
+```ruby
+  def fibo n, cache=[0, 1]
+    return cache[n] if cache[n]
+    cache[n] = fibo( n.pred, cache ) + fibo( n.pred.pred, cache )
+  end
+```
+
+It is still amazing how the specialized cache initialisation allows us to get rid of the original if statement.
+
+However the general case would read like this
+
+```ruby
+    def f n, cache = {}
+      args_hash = some_hash_fn n  # n is all args here 
+      return cache[args_hash] if cache[args_hash]
+      cache[args_hash] = f_implemenetation( some_fn(n), cache )
+    end
+```
+
+While a memoization mechanisme built into the language allos to write things like
+
+```ruby
+    def_memoized f *args
+      ...
+    end
+
+    def f *args
+      ...
+    end
+    memoize :f
+
+    # Which can be written as
+    memoize \
+      def f *args
+        ...
+      end
+
+   memoized do
+     def f *args
+       ...
+     end
+   end
+```
+
+This gem opts for the `memoize` method in the `Module` class as this allows for
+two different syntaxes
+
+```ruby
+    memoize def f ...
+    end
+
+    #
+    def f ...
+    end
+    memoize :f
+    
+```
+
+#### Lazy Attributes
+
+Are just parameterless memoized methods, excatly the same as `let` bindings in [RSpec](http://www.rubydoc.info/gems/rspec-core/RSpec/Core/MemoizedHelpers/ClassMethods#let-instance_method).
+
+```ruby
+    lazy_attr( :config ){ YAML.read config_file }
+```
+
+One could say they are just syntactic sugar for
+
+```ruby
+    memoize def config
+      YAML.read config_file
+    end
+```
+
+One would be correct, but lazy attributes are many (in some of my modules and classes) and have a semantic role often very similar to
+the example above. They are by nature static while methods like the shortest path or fibonacci are highly dynamic.
+
+For details see the corresponding [QED demo](https://github.com/RobertDober/lab42_core/blob/master/demo/memoization.md).
+
+#### Gotchas
+
+Do not, I repeat, **Do not** memoize methods with side effects!
+
+The exception is _cached reading_ as in the example above.
+
+Do not call memoized methods with arguments that cannot be used as Hash keys like e.g. BasicObject instances or other objects not responding to the **original** `hash` method.
+
 ## Array
 
 Can be used after `require 'lab42/core'` or `require 'lab42/core/array'`  
@@ -91,10 +191,23 @@ For details see the corresponding [QED demo](https://github.com/RobertDober/lab4
 
 ## Hash
 
+### #only
+
 ```ruby
   {a: 42, b: 43}.only :a, :c # ===> {a: 42}
 ```
 
+### #fetch! (read fetch and set)
+
+```ruby
+    a = {a: 42}
+    a.fetch!(b, 43) # or a.fetch!(b){43}
+    a == {a: 42, b: 43 } # true
+```
+
+**N.B.** Unlike `Hash#fetch` `Hash#fetch!` will **not** warn you that the block superseeds the default arg if both
+are provided (after all there is a !).
+
 For details see the corresponding [QED demo](https://github.com/RobertDober/lab42_core/blob/master/demo/hash.md).
 
 ## Fn

data/lib/lab42/core/hash.rb

@@ -16,4 +16,12 @@ class Hash
       default
     end
   end
+
+  def fetch! key, *defaults, &defblk
+    default_present = !(defaults.empty? && defblk.nil?)
+    return fetch key unless default_present
+    fetch key do
+      self[ key ] = defblk ? defblk.() : defaults.first
+    end
+  end
 end # class Hash

data/lib/lab42/core/memoization.rb

@@ -0,0 +1,14 @@
+require_relative 'hash'
+class Module
+  def memoize sym
+    orig_method = instance_method sym
+    define_method sym do |*args|
+      ivar_name = "@__#{sym}__" 
+      instance_variable_set ivar_name, {} unless instance_variable_defined? ivar_name
+      instance_variable_get( ivar_name ).fetch! args do
+        # Not cached yet!!!
+        orig_method.bind( self ).( *args )
+      end
+    end
+  end
+end

data/lib/lab42/core/version.rb

@@ -1,5 +1,5 @@
 module Lab42
   module Core
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end # module Core
 end # module Lab42

data/lib/lab42/core.rb

@@ -7,3 +7,4 @@ require_relative './core/enumerable'
 require_relative './core/file'
 require_relative './core/hash'
 require_relative './core/open_object'
+require_relative './core/memoization'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_core
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Robert Dober
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-06 00:00:00.000000000 Z
+date: 2015-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: forwarder2
@@ -126,6 +126,7 @@ files:
 - lib/lab42/core/file.rb
 - lib/lab42/core/fn.rb
 - lib/lab42/core/hash.rb
+- lib/lab42/core/memoization.rb
 - lib/lab42/core/meta.rb
 - lib/lab42/core/old_ruby2.rb
 - lib/lab42/core/open_object.rb