bud 0.9.4 → 0.9.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 628133a838208bab16e5ec51d166da3b35803cc1
+  data.tar.gz: afeab2b5aaa75b379aa5561559fb7acc89cfb50a
+SHA512:
+  metadata.gz: cd64cbf997cd2592e90f1be28e9818c074ff8bbfbb0cc997dfe0d4af455484e98959f72408ab70487ba29de32cfd10fdf7d662bca702c8ff92ddf82862d47941
+  data.tar.gz: 541c9f257e269de04137d6217e8960c680e1864cc9065cd12eb6a04eecf869dc6080ea184ac12c8d45e0f24ae589339aaddf99ea47c4020b2d3060a0669a7b00

data/History.txt

@@ -1,3 +1,109 @@
+== 0.9.8 / ???
+
+* Fix bug in the stratification algorithm
+* Fix bug with insertions into stdio inside bootstrap blocks
+* Improve error message when <~ applied to a collection type that doesn't
+  support it (#316)
+* Fix rescan logic for Zookeeper-backed collections (#317)
+* Fix rescan logic for chained negation operators in a single rule
+* Support + operator for concatenating tuples
+* More consistent behavior for #==, #eql?, and #hash methods on Bud tuple
+  objects (TupleStruct)
+* Fix intermittent EM::ConnectionNotBound exceptions during the Bud shutdown
+  sequence
+* Improve stratification algorithm to be slightly more aggressive; that is, we
+  can place certain rules in an earlier strata than we were previously
+  (partially fixes #277)
+* Add Rakefile to simplify common development operations (Joel VanderWerf, #324)
+
+== 0.9.7 / 2013-04-22
+
+* Avoid raising an exception when Bud is used with Ruby 2.0. There isn't
+  anything special that Bud itself needs to do to support Ruby 2.0, but
+  RubyParser doesn't properly support 2.0 yet. So using 2.0-only syntax in Bud
+  rules is unlikely to work (until RubyParser is updated), but no other problems
+  have been observed.
+* Reject <= on collections from outside Bloom rules (#289, Aaron Davidson). The
+  previous behavior was error-prone: inserting into a scratch collection via <=
+  was not rejected but the inserted data would immediately be discarded at the
+  beginning of the next tick. Hence, it is simpler to require <+ or <~ for all
+  insertions from outside Bloom rules.
+* Fix bug in join operators whose qualifiers reference collections defined
+  inside imported modules (#301)
+* Fix bug in join operators when the same table and column name appears on the
+  LHS of multiple join predicates (#313)
+* Fix bug in outer joins with multiple predicates (#315)
+* Fix several bugs in rescan/invalidation logic for tables in the presence of
+  upstream deletions (#303)
+* Fix regression in file_reader collections (#304)
+* Improve chaining of notin operators
+* Optimize join evaluation with multiple predicates
+* Optimize notin self joins
+* Improve error reporting for syntax errors on temp collections (#310)
+* Add Travis CI integration hooks (#300, Josh Rosen)
+
+Lattices:
+
+* Rename lmap#apply_monotone to lmap#apply. Also, allow #apply to take either
+  monotone functions or morphisms, and improve error reporting.
+* Add lmap#filter. This takes an lmap whose values are elements of the lbool
+  lattice and returns an lmap containing only those k/v pairs where the value is
+  true.
+* More intuitive lattice equi-join syntax (lset#eqjoin). Rather than specifying
+  the join predicate(s) using array indexes, instead allow them to be specified
+  using a hash of field names, as in traditional Bloom joins. This only works
+  when the lset contains Structs.
+* Remove lset#project, and allow lset#eqjoin to take zero predicates; in the
+  latter case, eqjoin computes the Cartesian product.
+* Support deletion rules (<-) with lattice values on the RHS
+
+== 0.9.6 / 2013-02-25
+
+* Support syntax sugar for initializing lattices (#294). For example, rather
+  than writing "foo <= Bud::MaxLattice.new(2)", you can now just write "foo <=
+  2". Note that, due to a bug in the superator gem, you cannot use this syntax
+  with the <+ operator.
+* Allow nested lattice values to be sent over channels (#295, patch from Josh
+  Rosen). Lattice values could previously be sent as a field value in a tuple
+  delivered over a channel, but they could not be embedded arbitrarily deeply
+  within tuples (e.g., lattices nested within an array could not previously be
+  sent as a field value).
+* Support "Comparable" for Bud::Lattice values
+* Add support for lattices to rebl
+* Reject attempts to insert into stdio via <+ (#288)
+* Restore functionality of reading from stdio (i.e., stdin) with MRI 1.9
+* Improve MRI 1.8 compatibility
+* Require ruby_parser >= 3.1.0
+* Fix bug in bootstrap blocks for lattice values
+* Fix bug in rescan/invalidation for rules that reference lattice values and use
+  the <+ or <~ operators (#290)
+* Fix bug in rescan logic for notin operator (#291)
+* Fix bug in notin operators involving self joins (#298)
+* Fix error when output from a notin operator was fed into a lattice
+
+== 0.9.5 / 2012-11-24
+
+* Lattice branch (Bloom^L) merged
+* Compatibility with recent versions of ruby_parser (3.0.2+) and ruby2ruby
+  (2.0.1+). Older versions of these two gems are no longer supported
+* Add support for aggregate functions that take multiple input columns
+* Add built-in aggregate function accum_pair(x, y), which produces a Set of
+  pairs (two-element arrays [x,y])
+* Support user-specified code blocks in payloads(), argagg(), argmin() and
+  argmax()
+* Change behavior of BudChannel#payloads for channels with two
+  columns. Previously we returned a single *column* (scalar) value in this case;
+  now we always return a tuple with k-1 columns
+* More consistent behavior for BudCollection#sort when used outside Bloom
+  programs
+* Restore support for each_with_index() over Bud collections
+* Restore functionality of Zookeeper-backed Bud collections and fix
+  incompatibility with recent (> 0.4.4) versions of the Zookeeper gem
+* Optimize parsing of Bloom statements, particularly for large Bloom programs
+* Fix bug in argagg state materialization
+* Fix bug in chaining argmin() or argmax() expressions
+* Fix bug in chaining notin() expressions
+
 == 0.9.4 / 2012-09-06
 
 * Optimize grouping performance

data/README.md

@@ -1,3 +1,4 @@
+[![Build Status](https://travis-ci.org/bloom-lang/bud.svg?branch=v0.9.8)](https://travis-ci.org/bloom-lang/bud)
 # Bud
 
 This is Bud, a.k.a. "Bloom Under Development".  It is an initial cut at a Bloom
@@ -11,11 +12,12 @@ documentation.
 Main deficiencies at this point are:
 
 - No Ruby constraints: Within Bloom programs the full power of Ruby is also
-  available, including mutable state.  This allows programmers to get outside
-  the Bloom framework and lose cleanliness.
+  available, including mutable state. This allows programmers to get outside the
+  Bloom framework and lose cleanliness.
 
-- Compatibility: Bud only works with Ruby (MRI) 1.8.7 and 1.9. JRuby and other
-  Ruby implementations are currently not supported.
+- Compatibility: Bud only works with Ruby (MRI) 1.8.7 and 1.9. Bud also has
+  experimental support for Ruby 2.0. JRuby and other Ruby implementations are
+  currently not supported.
 
 ## Installation
 

data/Rakefile

@@ -0,0 +1,91 @@
+require 'rake'
+require 'rake/testtask'
+
+PRJ = "bud"
+
+def version
+  @version ||= begin
+    $LOAD_PATH.unshift 'lib'
+    require 'bud/version'
+    warn "Bud::VERSION not a string" unless Bud::VERSION.kind_of? String
+    Bud::VERSION
+  end
+end
+
+def tag
+  @tag ||= "v#{version}"
+end
+
+desc "Run all tests"
+task :test => "test:unit"
+
+TESTS = FileList["test/tc_*.rb"]
+SLOW_TESTS = %w{ test/tc_execmodes.rb }
+
+namespace :test do
+  desc "Run unit tests"
+  Rake::TestTask.new :unit do |t|
+    t.libs << "lib"
+    t.ruby_opts = %w{ -C test }
+    t.test_files = TESTS.sub('test/', '')
+      ### it would be better to make each tc_*.rb not depend on pwd
+  end
+
+  desc "Run quick unit tests"
+  Rake::TestTask.new :quick do |t|
+    t.libs << "lib"
+    t.ruby_opts = %w{ -C test }
+    t.test_files = TESTS.exclude(*SLOW_TESTS).sub('test/', '')
+  end
+
+  desc "Run quick non-zk unit tests"
+  Rake::TestTask.new :quick_no_zk do |t|
+    t.libs << "lib"
+    t.ruby_opts = %w{ -C test }
+    t.test_files = TESTS.
+      exclude('test/tc_zookeeper.rb').
+      exclude(*SLOW_TESTS).
+      sub('test/', '')
+  end
+end
+
+desc "Commit, tag, and push repo; build and push gem"
+task :release => "release:is_new_version" do
+  require 'tempfile'
+  
+  sh "gem build #{PRJ}.gemspec"
+
+  file = Tempfile.new "template"
+  begin
+    file.puts "release #{version}"
+    file.close
+    sh "git commit --allow-empty -a -v -t #{file.path}"
+  ensure
+    file.close unless file.closed?
+    file.unlink
+  end
+
+  sh "git tag #{tag}"
+  sh "git push"
+  sh "git push --tags"
+  
+  sh "gem push #{tag}.gem"
+end
+
+namespace :release do
+  desc "Diff to latest release"
+  task :diff do
+    latest = `git describe --abbrev=0 --tags --match 'v*'`.chomp
+    sh "git diff #{latest}"
+  end
+
+  desc "Log to latest release"
+  task :log do
+    latest = `git describe --abbrev=0 --tags --match 'v*'`.chomp
+    sh "git log #{latest}.."
+  end
+
+  task :is_new_version do
+    abort "#{tag} exists; update version!" unless `git tag -l #{tag}`.empty?
+  end
+end

data/bin/budlabel

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bud'
+require 'getopt/std'
+require 'bud/labeling/labeling'
+require 'bud/labeling/bloomgraph'
+require 'bud/labeling/budplot_style'
+
+$LOAD_PATH.unshift(".")
+
+@opts = Getopt::Std.getopts("r:i:p:O:CP")
+
+unless @opts["r"] and @opts["i"]
+  puts "USAGE:"
+  puts "-r REQUIRE"
+  puts "-i INCLUDE"
+  puts "[-p INCLUDE PATH]"
+  puts "[-O <FMT> Output a graphviz representation of the module in FMT format (pdf if not specified)."
+  puts "-C Concise output -- Associate a single label with each output interface"
+  puts "-P Path-based output -- For each output interface, attribute a label to paths from each input interface"
+  exit
+end
+
+hreadable = {
+  "D" => "Diffluent: Nondeterministic output contents.",
+  "A" => "Asynchronous.  Nondeterministic output orders.",
+  "N" => "Nonmonotonic.  Output contents are sensitive to input orders.",
+  "Bot" => "Monotonic.  Order-insensitive and retraction-free."
+}
+
+if @opts["p"]
+  $LOAD_PATH.unshift @opts["p"]
+end
+
+require @opts["r"]
+c = Label.new(@opts["i"])
+
+puts "--- Report for module #{@opts["i"]} ---"
+
+if @opts["C"]
+  puts "---------------"
+  puts "Output\t\tLabel"
+  puts "---------------"
+  c.output_report.each_pair do |k, v|
+    puts [k, hreadable[v]].join("\t")
+  end
+end
+
+if @opts["P"]
+  c.path_report.each_pair do |output, inpaths|
+    puts ""
+    puts "--------------------"
+    puts "Output\tInput\tLabel"
+    puts "--------------------"
+    puts output
+    inpaths.each_pair do |inp, lbl|
+      puts "\t#{inp}\t#{hreadable[lbl]}"
+    end
+  end
+end
+
+c.write_graph(@opts["O"]) if @opts["O"]

data/bin/budplot

@@ -21,6 +21,10 @@ def make_instance(mods)
   # If we're given a single identifier that names a class, just return an
   # instance of that class. Otherwise, define a bogus class that includes all
   # the module names specified by the user and return an instance.
+  tmpserver = TCPServer.new('127.0.0.1', 0) # get a free port
+  default_params = {:dbm_dir => "/tmp/budplot_dbm_" + SecureRandom.uuid.to_s, :port => tmpserver.addr[1]}
+
+
   mods.each do |m|
     unless is_constant? m
       puts "Error: unable to find definition for module or class \"#{m}\""
@@ -30,7 +34,7 @@ def make_instance(mods)
     mod_klass = eval m
     if mod_klass.class == Class
       if mods.length == 1
-        return mod_klass.new
+        return mod_klass.new(default_params)
       else
         puts "Error: cannot intermix class \"#{mod_klass}\" with modules"
         exit
@@ -50,7 +54,7 @@ def make_instance(mods)
               ]
   class_def = def_lines.flatten.join("\n")
   eval(class_def)
-  f =FooBar.new
+  f = FooBar.new(default_params)
   3.times{ f.tick }
   f
 end
@@ -77,8 +81,8 @@ def process(mods)
   d = make_instance(mods)
 
   interfaces = {}
-  d.t_provides.each do |name, is_input|
-    interfaces[name] = is_input
+  d.t_provides.to_a.each do |prov|
+    interfaces[prov.interface] = prov.input
   end
 
   tabinf = {}
@@ -201,13 +205,18 @@ def get_trace_data
 end
 
 if ARGV.length < 2
-  puts "Usage: budplot LIST_OF_FILES LIST_OF_MODULES_OR_CLASSES"
+  puts "Usage: budplot [-I PATH_TO_RUBY_INCLUDES] LIST_OF_FILES LIST_OF_MODULES_OR_CLASSES"
   exit
 end
 
-@opts = Getopt::Std.getopts("t:")
-
-
+@opts = Getopt::Std.getopts("I:t:")
+unless @opts["I"].nil?
+  if @opts["I"].class == Array
+    @opts["I"].each{|i| $:.unshift i} 
+  else  
+    $:.unshift @opts["I"]
+  end
+end
 
 @data = get_trace_data
 `mkdir bud_doc`
@@ -215,6 +224,7 @@ end
 modules = []
 ARGV.each do |arg|
   if File.exists? arg
+    arg = File.expand_path arg
     require arg
   else
     modules << arg

data/bin/budtimelines

@@ -10,7 +10,7 @@ include VizUtil
 
 module Depends
   state do
-    table :depends, [:rid, :lhs, :op, :rhs, :nm]
+    table :depends, [:bud_obj, :rid, :lhs, :op, :rhs, :nm, :in_body]
   end
 end
 
@@ -49,7 +49,7 @@ end
 module DeltaLogic
   include TPSchema
   bloom do
-    zerod_cards <= cardinalities{|c| c + [c.bud_time-1]}
+    zerod_cards <= cardinalities{|c| c.to_a + [c.bud_time-1]}
     zerod_cards <= (times * depends).pairs do |t, d|
       unless cardinalities{|c| c[1] if c[0] == t.bud_time}.include? d[1]
         [t.bud_time, d[1], 0, t.bud_time - 1]

data/bin/budvis

@@ -28,7 +28,13 @@ usage unless ARGV[0]
 usage if ARGV[0] == '--help'
 
 meta, data = get_meta2(BUD_DBM_DIR)
-vh = VizHelper.new(meta[:tabinf], meta[:cycle], meta[:depends], meta[:rules], ARGV[0], meta[:provides])
+
+# prune outbufs from tabinf
+tabinf = meta[:tabinf].find_all do |k|
+  !(k[1] == "Bud::BudChannel" and k[0] =~ /_snd\z/)
+end
+
+vh = VizHelper.new(tabinf, meta[:cycle], meta[:depends], meta[:rules], ARGV[0], meta[:provides])
 data.each do |d|
   vh.full_info << d
 end

data/docs/README.md

@@ -6,28 +6,19 @@ Welcome to the documentation for *Bud*, a prototype of Bloom under development.
 The documents here are organized to be read in any order, but you might like to
 try the following:
 
-* [intro.md][intro]: A brief introduction to Bud and Bloom.
-* [getstarted.md][getstarted]: A quickstart to teach you basic Bloom
+* [intro](intro.md): A brief introduction to Bud and Bloom.
+* [getstarted](getstarted.md): A quickstart to teach you basic Bloom
   concepts, the use of `rebl` interactive terminal, and the embedding of Bloom
   code in Ruby via the `Bud` module.
-* [operational.md][operational]: An operational view of Bloom, to provide
+* [operational](operational.md): An operational view of Bloom, to provide
   a more detailed model of how Bloom code is evaluated by Bud.
-* [cheat.md][cheat]: A concise "cheat sheet" to remind you about Bloom syntax.
-* [modules.md][modules]: An overview of Bloom's modularity features.
-* [ruby\_hooks.md][ruby_hooks]: Bud module methods that allow you to
+* [cheat](cheat.md): Full documentation of the language constructs in a concise "cheat sheet" style.
+* [modules](modules.md): An overview of Bloom's modularity features.
+* [ruby_hooks](ruby\_hooks.md): Bud module methods that allow you to
   interact with the Bud evaluator from other Ruby threads.
-* [visualizations.md][visualizations]: Overview of the `budvis` and
+* [visualizations](visualizations.md): Overview of the `budvis` and
   `budplot` tools for visualizing Bloom program analyses.
-* [bfs.md][bfs]: A walkthrough of the Bloom distributed filesystem.
-
-[intro]:          /bloom-lang/bud/blob/master/docs/intro.md
-[getstarted]:     /bloom-lang/bud/blob/master/docs/getstarted.md
-[operational]:    /bloom-lang/bud/blob/master/docs/operational.md
-[cheat]:          /bloom-lang/bud/blob/master/docs/cheat.md
-[modules]:        /bloom-lang/bud/blob/master/docs/modules.md
-[ruby_hooks]:     /bloom-lang/bud/blob/master/docs/ruby_hooks.md
-[visualizations]: /bloom-lang/bud/blob/master/docs/visualizations.md
-[bfs]:            /bloom-lang/bud/blob/master/docs/bfs.md
+* [bfs](bfs.md): A walkthrough of the Bloom distributed filesystem.
 
 In addition, the [bud-sandbox](http://github.com/bloom-lang/bud-sandbox) GitHub
 repository contains lots of useful libraries and example programs built using

data/docs/cheat.md

@@ -21,15 +21,23 @@ As in Ruby, backslash is used to escape a newline.<br>
     end
     
 ## State Declarations ##
-A `state` block contains Bud collection definitions. A Bud collection is a *set*
-of *facts*; each fact is an array of Ruby values. Note that collections do not
-contain duplicates (inserting a duplicate fact into a collection is ignored).
+
+A `state` block contains definitions of two kinds of program state:
+*collections* and *lattices*. A Bud collection is a *set* of *facts*; each fact
+is an array of Ruby values. Note that collections do not contain duplicates
+(inserting a duplicate fact into a collection is ignored).
 
 Like a table in a relational database, a subset of the columns in a collection
 makeup the collection's _key_. Attempting to insert two facts into a collection
 that agree on the key columns (but are not duplicates) results in a runtime
 exception.
 
+A lattice represents a value that *grows* over time, where the definition of
+"growth" depends on the kind of lattice in question. For example, an `lset`
+lattice contains a set of facts that grows over time (similar to a traditional
+Bud collection), whereas an `lmax` lattice holds an increasing integer
+value. For more information on lattices, see the section below.
+
 ### Default Declaration Syntax ###
 *BudCollection :name, [keys] => [values]*
 
@@ -186,7 +194,7 @@ implicit map:
     end
 
 ## BudCollection-Specific Methods ##
-`bc.schema`: returns the schema of `bc` (Hash of key column names => non-key column names). Note that for channels, this omits the location specifier (<tt>@</tt>).<br>
+`bc.schema`: returns the schema of `bc` (Hash of key column names => non-key column names; if no non-key columns, just an Array of key column names). Note that for channels, this omits the location specifier (<tt>@</tt>).<br>
 
 `bc.cols`: returns the column names in `bc` as an Array<br>
 
@@ -224,14 +232,14 @@ Output the facts in `bc` that do not appear in `bc2`, as follows. First, we form
      :attr2`).
 
   2. If a code block is specified, invoke the block on every pair of matching
-     tuples in the join result. Any matches for which the block returns `nil`
+     tuples in the join result. Any matches for which the block returns `false`
      are removed from `t`.
 
 Finally, we output every tuple of `bc` that does *not* appear in `t`.
 
     # output items from foo if (a) there is no matching key in bar, or
     # (b) all matching keys in bar have a smaller value
-    stdio <~ foo.notin(bar, :key=>:key) {|f, b| true if f.val <= b.val}
+    stdio <~ foo.notin(bar, :key=>:key) {|f, b| f.val <= b.val}
 
     
 ## SQL-style grouping/aggregation (and then some) ##
@@ -239,18 +247,12 @@ Finally, we output every tuple of `bc` that does *not* appear in `t`.
 * `bc.group([:col1, :col2], min(:col3))`.  *akin to min(col3) GROUP BY col1,col2*
   * exemplary aggs: `min`, `max`, `bool_and`, `bool_or`, `choose`
   * summary aggs: `sum`, `avg`, `count`
-  * structural aggs: `accum` *accumulates inputs into a Set*
+  * structural aggs: `accum`, `accum_pair` *accumulates inputs into a Set; accum_pair takes two inputs and accumulates a Set of pairs (two element arrays)*
 * `bc.argmax([:attr1], :attr2)` &nbsp;&nbsp;&nbsp;&nbsp; *returns the bc items per attr1 that have highest attr2*
 * `bc.argmin([:attr1], :attr2)`
 * `bc.argagg(:exemplary_agg_name, [:attr1], :attr2))`.  *generalizes argmin/max: returns the bc items per attr1 that are chosen by the exemplary
 aggregate named*
 
-### Built-in Aggregates: ###
-
-* Exemplary aggs: `min`, `max`, `choose`
-* Summary aggs: `count`, `sum`, `avg`
-* Structural aggs: `accum`
-
 Note that custom aggregation can be written using `reduce`.
 
 ## Collection Combination (Join) ###
@@ -313,6 +315,103 @@ The schema of a temp collection in inherited from the rhs; if the rhs has no
 schema, a simple one is manufactured to suit the data found in the rhs at
 runtime: `[c0, c1, ...]`.
 
+## Lattices ##
+
+In addition to traditional Bud collections and relational-style statements that
+operate over collections, Bud also supports lattices and rules that operate over
+lattices. Lattices provide a way to represent values that *grow over time*,
+where the definition of "growth" depends on the kind of lattice. The following
+built-in lattice types are currently supported:
+
+<table>
+  <tr>
+    <td><b>Name</b></td>
+    <td><b>Description</b></td>
+    <td><b>Initial Value</b></td>
+    <td><b>Monotone Functions</b></td>
+  </tr>
+
+  <tr>
+    <td><code>lbool</code></td>
+    <td>Threshold test (<code>false</code> => <code>true</code> conditional)</td>
+    <td>false</td>
+    <td>when_true</td>
+  </tr>
+
+  <tr>
+    <td><code>lmax</code></td>
+    <td>Increasing numeric value</td>
+    <td>-&infin;</td>
+    <td>gt(n), gt_eq(n), +(n), -(n)</td>
+  </tr>
+
+  <tr>
+    <td><code>lmin</code></td>
+    <td>Decreasing numeric value</td>
+    <td>+&infin;</td>
+    <td>lt(n), lt_eq(n), +(n), -(n)</td>
+  </tr>
+
+  <tr>
+    <td><code>lset</code></td>
+    <td>Growing set of values</td>
+    <td>empty set</td>
+    <td>contains?, eqjoin, filter, intersect, product, project, size</td>
+  </tr>
+
+  <tr>
+    <td><code>lpset</code></td>
+    <td>Growing set of non-negative numeric values</td>
+    <td>empty set</td>
+    <td>contains?, eqjoin, filter, intersect, product, project, size, sum</td>
+  </tr>
+
+  <tr>
+    <td><code>lbag</code></td>
+    <td>Growing multiset of values</td>
+    <td>empty multiset</td>
+    <td>contains?, multiplicity, intersect, product, project, size</td>
+  </tr>
+
+  <tr>
+    <td><code>lmap</code></td>
+    <td>Map from keys to lattice values</td>
+    <td>empty map</td>
+    <td>at, intersect, key?, key_set, project, size</td>
+  </tr>
+</table>
+
+Lattices can be declared in `state` blocks in a similar manner to traditional
+Bud collections. Similarly, Bloom rules can invoke functions on lattice
+values. A simple Bloom program that uses lattices to compute a quorum vote is as
+follows:
+
+```ruby
+QUORUM_SIZE = 5
+RESULT_ADDR = "example.org"
+
+class QuorumVote
+  include Bud
+
+  state do
+    channel :vote_chn, [:@addr, :voter_id]
+    channel :result_chn, [:@addr]
+    lset    :votes
+    lmax    :vote_cnt
+    lbool   :vote_done
+  end
+
+  bloom do
+    votes      <= vote_chn {|v| v.voter_id}
+    vote_cnt   <= votes.size
+    got_quorum <= vote_cnt.gt_eq(QUORUM_SIZE)
+    result_chn <~ got_quorum.when_true { [RESULT_ADDR] }
+  end
+end
+```
+
+For more information on lattice support in Bloom, see this [recent paper](http://db.cs.berkeley.edu/papers/socc12-blooml.pdf).
+
 ## Bud Modules ##
 A Bud module combines state (collections) and logic (Bloom rules). Using modules allows your program to be decomposed into a collection of smaller units.