yopt 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2b1eaa4ca004e729d902f06b93fca46dd526175
-  data.tar.gz: 920c701a92b2f4a74698b376e81035d049d9bc74
+  metadata.gz: c229455d1c89285665fc049eba0ba28e3ccb476e
+  data.tar.gz: ce0b59c5d06a0860ab05e23b5ec66e0fd98fae8c
 SHA512:
-  metadata.gz: 1fe9eed7ba9150bef20625b851109cfa872ed1b961ef3e9552126c200f841e45faf978b6d9f2539e516b236ef9a42ae224ccd260363430f75be15a63ae2f3d73
-  data.tar.gz: caff9b6961f3217f9d1894bda7bf30227026d86ff28fe043a20da52c05955c9837b93b9ce058a70d1e73583ba5b0294b9e18e1773190c898b73d49d7795f624d
+  metadata.gz: 08b12da1909c7357a303e6d1f467e439561d02a5dc81d34a014d02af574d3b441c64c3be52fc5babe208a85c27ea20ef47fe83555bdb7435453e7ec497aaf084
+  data.tar.gz: a4935ac26dbf235085138e6adcbad5d6a3f172f744d239c53c6988d7f2606c7e3853dca3581dcbc9e5b0d9eb4180f3ef3e6f9e9087a01b1a0bf201e4f70dfdce

data/README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://travis-ci.org/lbarasti/yopt.svg?branch=master)](https://travis-ci.org/lbarasti/yopt) [![Coverage Status](https://coveralls.io/repos/github/lbarasti/yopt/badge.svg?branch=master)](https://coveralls.io/github/lbarasti/yopt?branch=master)
+
 # Yopt
 
 A [Scala](http://www.scala-lang.org/api/current/index.html#scala.Option) inspired gem that introduces `Option`s to Ruby while aiming for an idiomatic API.
@@ -157,11 +159,24 @@ Option[42].zip Option[0], Option["str"] # Some([42, 0, "str"])
 ```
 
 
+### #or_else
+When writing an application whose functionality depends on the availability of other services/information, it's a good idea to prepare for the scenario where such services/information are not available. 
+
+`#or_else` lets us define a chain of block calls that will stop as soon as one of them returns a non-empty option.
+```ruby
+get_postcode = -> email do
+  get_from_cache[email]
+    .or_else { get_from_db[email] }
+    .or_else { get_from_remote[email] }
+end
+```
+
+
 ### #grep
 We often find ourselves filtering data before applying a transformation...
 
 ```ruby
-opt.filter {|v| (1...10).include? v}.map {|v| v + 1}
+opt.select {|v| (1...10).include? v}.map {|v| v + 1}
 ```
 
 In this scenario, `Option#grep` can sometimes make the code more concise
@@ -177,7 +192,7 @@ is_positive = lambda {|x| x > 0}
 
 opt.grep(is_positive) {|v| Math.log(v)}
 # is equivalent to
-opt.filter(&is_positive).map {|v| Math.log(v)}
+opt.select(&is_positive).map {|v| Math.log(v)}
 ```
 
 

data/lib/yopt.rb

@@ -8,7 +8,7 @@ module Yopt
   module Option
     include Enumerable
     def self.ary_to_type value
-      raise Option.invalid_argument('an array-like object', value) unless value.respond_to? :to_ary
+      raise Option.invalid_argument('Argument must be an array-like object', value) unless value.respond_to? :to_ary
       return value if value.is_a? Option
       if value.to_ary.empty? then None else Some.new(value.to_ary.first) end
     end
@@ -43,9 +43,10 @@ module Yopt
     def ^ lambda
       self | Yopt.lift(&lambda)
     end
-    def or_else other
-      raise Option.invalid_argument('an Option', other) unless other.is_a? Option
-      if empty? then other else self end
+    def or_else
+      return self unless empty?
+      other = yield
+      other.is_a?(Option) ? other : raise(Option.invalid_argument('Block should evaluate to an Option', other))
     end
     def get_or_else
       raise ArgumentError, 'missing block' unless block_given?
@@ -58,7 +59,7 @@ module Yopt
     def inspect() to_s end
     private
     def self.invalid_argument type_str, arg
-      TypeError.new "Argument must be #{type_str}. Found #{arg.class}"
+      TypeError.new "#{type_str}. Found #{arg.class}"
     end
   end
   class Some

data/lib/yopt/version.rb

@@ -1,3 +1,3 @@
 module Yopt
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yopt
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - lorenzo.barasti
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-02 00:00:00.000000000 Z
+date: 2016-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,34 +52,32 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 description: The Option type models the possible absence of a value. It lets us deal
   with the uncertainty related to such a value being there without having to resort
   to errors or conditional blocks.
-email: 
+email: yopt-user-group@googlegroups.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
-- CODE_OF_CONDUCT.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
-- docs/README.template.md
-- docs/basics.rb
-- docs/enumerable_methods.md
-- docs/full_example_snippet.rb
-- docs/including yopt.md
-- docs/usage_reduce.rb
-- docs/usage_snippet.rb
-- docs/usage_zip.rb
 - lib/yopt.rb
 - lib/yopt/version.rb
-- yopt.gemspec
 homepage: http://lbarasti.github.io/yopt
 licenses:
 - MIT
@@ -105,4 +103,3 @@ signing_key:
 specification_version: 4
 summary: Scala-inspired Options for the idiomatic Rubyist
 test_files: []
-has_rdoc: 

data/.gitignore

@@ -1,12 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-/vendor
-/yopt-0.1.0.gem
-/_site/

data/.travis.yml

@@ -1,5 +0,0 @@
-language: ruby
-rvm:
-  - 2.0.0
-  - 2.2.0
-before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -1,13 +0,0 @@
-# Contributor Code of Conduct
-
-As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
-
-Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
-
-This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'pry', '~> 0.10.3'
-gem 'rb-readline', '~> 0.5.3'
-# Specify your gem's dependencies in yopt.gemspec
-gemspec

data/Rakefile

@@ -1,39 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList['test/**/*_test.rb']
-end
-
-task :docs do
-  partial_keyword = '<<<<<'
-  ignore_keyword = "# IGNORE\n"
-  comment_keyword = "# COMMENT\n"
-  src = './docs/README.template.md'
-  target = './README.md'
-  content = File.readlines(src).flat_map {|line|
-    if line.lstrip.start_with?(partial_keyword)
-      partial_file = line.lstrip[partial_keyword.size...-1]
-      sh 'ruby', partial_file
-      File.readlines partial_file
-    else
-      line
-    end
-  }
-  File.open(target, 'w') {|f|
-    content.reject{|line|
-      line.end_with?(ignore_keyword)
-    }.each_cons(2){|line1,line2|
-      next if line1.end_with?(comment_keyword)
-      if line2.end_with?(comment_keyword)
-        f.puts "#{line1.chomp} # #{line2.match(/'(.*)'/)[1]}\n"
-      else
-        f.puts line1
-      end
-    }
-  }
-end
-
-task :default => :test

data/bin/console

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "yopt"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-require "pry"
-Pry.start
-

data/bin/setup

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-IFS=$'\n\t'
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/docs/README.template.md

@@ -1,215 +0,0 @@
-# Yopt
-
-A [Scala](http://www.scala-lang.org/api/current/index.html#scala.Option) inspired gem that introduces `Option`s to Ruby while aiming for an idiomatic API.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'yopt'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install yopt
-
-## Basic usage
-
-The Option type models the possible absence of a value. It lets us deal with the uncertainty related to such a value being there without having to resort to errors or conditional blocks.
-
-Instances of Option are either an instance of `Yopt::Some` - meaning the option contains a value - or the object `Yopt::None` - meaning the option is *empty*.
-
-```ruby
-require 'yopt'
-
-some = Yopt::Some.new(42)
-none = Yopt::None
-```
-
-We can access and manipulate the optional value by passing a block to `Option#map`.
-
-```ruby
-some.map {|value| value + 2} # returns Some(44)
-none.map {|value| value + 2} # returns None
-```
-
-When we are not interested in the result of a computation on the optional value, it is a good practice to use `Option#each` rather than `Option#map`. That will make our intention clearer.
-
-```ruby
-some.each {|value| puts value} # prints 42
-none.each {|value| puts value} # does not print anything
-```
-
-We can safely retrieve the optional value by passing a default value to `Option#get_or_else`
-
-```ruby
-some.get_or_else {0} # returns 42
-none.get_or_else {0} # returns 0
-```
-
-Notice how we are passing a block rather than an argument. This makes the evaluation of the default value lazy. In other words the block will only be evaluated if the caller in None.
-
-This gives us the possibility to react in a special way to a None value without breaking the API fluency, e.g.
-
-```ruby
-opt.each {|v| do_something_with(v)}.get_or_else {log_failure}
-```
-
-We can also filter the optional value depending on how it evaluates against a block via `Option#select`
-
-```ruby
-some.select {|value| value < 0} # returns None
-none.select {|value| value < 0} # returns None
-some.select {|value| value > 0} # returns Some(42)
-```
-
-We can easily turn any object into an Option by means of `Option.call` - aliased to `Option[]` for convenience.
-For instance, this is useful when dealing with functions that might return `nil` to express the absence of a result.
-
-```ruby
-Yopt::Option[nil] # returns None
-Yopt::Option[42] # returns Some(42)
-```
-
-
-A combination of the few methods just introduced already allows us to implement some pretty interesting logic. Checkout `basics.rb` in the docs folder to get some inspiration.
-
-## Why opt?
-
-Using `Option`s reduces the amount of branching in our code and lets us deal with exceptional cases in a seamless way. No more check-for-nil, no more `rescue` blocks, just plain and simple data transformation.
-
-It also makes our code safer by treating *the absence of something* like a fully fledged object, and enables us to use the Null Object Pattern everywhere we want without the overhead of having to write specialized Null-type classes for different classes.
-
-## Advanced Usage
-### #reduce
-Given an Option `opt`, a value `c` and a lambda `f`,
-```
-opt.reduce(c, &f)
-```
-returns `c` if `opt` is `None`, and `f.(c, opt)` otherwise.
-
-This is a shortcut to
-```
-opt.map{|v| f.(c,v)}.get_or_else {c}`
-```
-
-
-### #flatten and #flat_map
-When working with functions returning `Option`, we might end up dealing with nested options...
-```ruby
-maybe_sqrt = lambda {|x| Yopt::Option[x >= 0 ? Math.sqrt(x) : nil]}
-maybe_increment = lambda {|x| Yopt::Option[x > 1  ? x + 1 : nil]}
-
-maybe_sqrt.(4).map {|v| maybe_increment.(v)} # Some(Some(3.0))
-maybe_sqrt.(1).map {|v| maybe_increment.(v)} # Some(None)
-```
-
-Usually, this is not what we want, so we call `Option#flatten` on the result
-```ruby
-maybe_sqrt.(4).map {|v| maybe_increment.(v)}.flatten # Some(3.0)
-maybe_sqrt.(1).map {|v| maybe_increment.(v)}.flatten # None
-```
-
-`Option#flat_map` combines the two calls into one
-
-```ruby
-maybe_sqrt.(4).flat_map {|v| maybe_increment.(v)} # Some(3.0)
-maybe_sqrt.(1).flat_map {|v| maybe_increment.(v)} # None
-```
-
-A difference to keep in mind is that `#flatten` will raise an error if the wrapped value does not respond to `#to_ary`
-```ruby
-Yopt.Option[42].flatten # raises TypeError: Argument must be an array-like object. Found Fixnum
-```
-whereas #flat_map behaves like #map when the passed block does not return an array-like value
-```ruby
-Yopt.Option[42].flat_map{|v| v} # returns Some(42)
-```
-
-
-### #zip
-When dealing with a set of `Option` instances, we might want to ensure that they are all defined - i.e. not __empty__ - before continuing a computation...
-```ruby
-email_opt.each(&send_pass_recovery) unless (email_opt.empty? or captcha_opt.empty?)
-```
-
-We can avoid `empty?` checks by using `Option#zip`
-```ruby
-email_opt.zip(captcha_opt).each{|(email,_)| send_pass_recovery(email)}
-```
-
-`Option#zip` returns `None` if any of the arguments is `None` or if the caller is `None`
-```ruby
-Yopt::None.zip Option[42] # None
-Option[42].zip Yopt::None # None
-Option[42].zip Option[0], Yopt::None, Option[-1] # None
-```
-
-When both the caller and all the arguments are defined then `zip` collects all the values in an Array wrapped in a `Yopt::Some`
-
-```ruby
-Option[42].zip Option[0], Option["str"] # Some([42, 0, "str"])
-```
-
-
-### #grep
-We often find ourselves filtering data before applying a transformation...
-
-```ruby
-opt.filter {|v| (1...10).include? v}.map {|v| v + 1}
-```
-
-In this scenario, `Option#grep` can sometimes make the code more concise
-
-```ruby
-opt.grep(1...10) {|v| v + 1}
-```
-
-`Option#grep` supports lambdas as well
-
-```ruby
-is_positive = lambda {|x| x > 0}
-
-opt.grep(is_positive) {|v| Math.log(v)}
-# is equivalent to
-opt.filter(&is_positive).map {|v| Math.log(v)}
-```
-
-
-## Haskell Data.Maybe cheat sheet
-
-Some (None?) might enjoy a comparison with Haskell's [Maybe](https://hackage.haskell.org/package/base/docs/Data-Maybe.html). Here is how the Data.Maybe API translate to Yopt.
-```ruby
-maybe default f opt     -> opt.map(&f).get_or_else {default}
-isJust opt              -> not opt.empty?
-isNothing opt           -> opt.empty?
-fromJust opt            -> opt.get
-fromMaybe default opt   -> opt.get_or_else {default}
-listToMaybe list        -> Option.ary_to_type list
-maybeToList opt         -> opt.to_a
-catMaybes listOfOptions -> listOfOptions.flatten
-mapMaybe f list         -> list.flat_map &f
-```
-
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/lbarasti/yopt. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/docs/basics.rb

@@ -1,37 +0,0 @@
-require_relative '../test/test_helper' # IGNORE
-# IGNORE
-require 'test/unit' # IGNORE
-include Test::Unit::Assertions # IGNORE
-# IGNORE
-class Cache < Hash
-  def maybe_get key
-    Yopt::Option[self[key]]
-  end
-
-  def store_if_some key, opt_value
-    opt_value.each {|value| self.store(key, value)}
-  end
-end
-
-def maybe_sqrt value
-  opt = Yopt::Option[value]
-  opt.select {|value| value >= 0}
-    .map {|value| Math.sqrt(value)}
-end
-
-def get_info cache, key
-  cache.maybe_get(key)
-    .map {|value| "found value %.2f for key %s" % [value, key]}
-    .get_or_else "value not found for key #{key}"
-end
-
-cache = Cache.new
-
-cache.store_if_some 42, maybe_sqrt(42)
-
-key = 42 + rand(2) # could be either 42 or 43
-
-puts get_info(cache, key)
-# IGNORE
-same_string(cache.maybe_get(key)).(Yopt::Some.new(Math.sqrt(42)).to_s) if key == 42 # IGNORE
-same_string(cache.maybe_get(key)).(Yopt::None.to_s) if key != 42 # IGNORE

data/docs/enumerable_methods.md

@@ -1,21 +0,0 @@
-## About Enumerable methods
-By including `Enumerable`, `Option` gives access to a set of methods which are either redundant or not really meaningful for a `Some` or a `None` object
-
-```ruby
-:slice_after :slice_before :slice_when :take :take_while :drop :drop_while :chunk :sort_by :each_entry :each_slice :group_by :minmax_by :sort :each_with_index :partition :find_all :max_by :min_by :reverse_each :each_cons :min :max :minmax
-```
-
-On the other hand, all the methods returning a boolean work as expected
-```ruby
-:all? :any? :include? :none? :one? :member?
-```
-
-The following methods work in a predictable way out-of-the-box
-```ruby
-:reduce :inject :each_with_object :cycle :to_set :find_index :find :detect :first :count :to_a :entries :to_h
-```
-
-While the following methods have custom definition to always return an `Option` rather than an `Array`
-```ruby
-:collect :map :flat_map :collect_concat :reject :select :zip :grep
-```

data/docs/full_example_snippet.rb

@@ -1,51 +0,0 @@
-require_relative '../test/test_helper' # IGNORE
-# IGNORE
-require 'test/unit' # IGNORE
-include Test::Unit::Assertions # IGNORE
-
-name2phone = [[:a, "+1 310-000-001"],
-              [:b, "+1 323-000-002"],
-              [:d, "+1 310-000-003"],
-              [:e, "+1 213-000-004"],
-              [:f, "+1 323-000-005"],
-              [:h, "+1 213-000-006"],
-              [:k, "+1 213-000-007"],
-              [:s, "+1 310-000-009"],
-              [:w, "+1 800-000-010"]]
-
-phone2postcode = [["+1 310-000-001", "CA 90210"],
-                  ["+1 310-000-003", "CA 90210"],
-                  ["+1 323-000-005", "CA 90028"],
-                  ["+1 213-000-006", "CA 90027"],
-                  ["+1 213-000-007", "CA 90027"],
-                  ["+1 800-000-010", "CA 91608"]]
-
-postcode2income = [["CA 90210", "$80000"],
-                  ["CA 91608", "$65000"]]
-
-
-lookup = -> (table, key) {
-  row_or_nil = table.find { |row| row.first == key }
-  Yopt::Option[row_or_nil] | :last
-}
-
-same_string( # IGNORE
-lookup.(name2phone, :s)
-).('Some(+1 310-000-009)') # COMMENT
-
-same_string( # IGNORE
-lookup.(name2phone, :x)
-).('None') # COMMENT
-
-same_string( # IGNORE
-same_string( # IGNORE
-same_string( # IGNORE
-lookup.(name2phone, :a)
-).('Some(+1 310-000-001)') # COMMENT
-  .flat_map {|phone| lookup.(phone2postcode, phone)}
-).('Some(CA 90210)') # COMMENT
-  .flat_map {|postcode| lookup.(postcode2income, postcode)}
-).('Some($80000)') # COMMENT
-
-# or if you want to go crazy-functional
-lookup.(name2phone, :a) | lookup.curry[phone2postcode] | lookup.curry[postcode2income]

data/docs/including yopt.md

@@ -1,8 +0,0 @@
-Some might find that having to specify the scope every time we want to use `Some` or `None` a bit too verbose. If that is the case, please consider that module scoping is a good receipe to avoid hideous naming clashes.
-
-If you understand the risk then you can either `include Yopt` or cherry-pick the tools you need from the module like so:
-
-```ruby
-Some = Yopt::Some
-None = Yopt::None
-```

data/docs/usage_reduce.rb

@@ -1,12 +0,0 @@
-require 'yopt'
-
-compute_increase = Yopt.lift {|user| 10000 if ['Bob', 'Joe', 'Eve'].member?(user)}
-
-base_salary = 20000
-user = ['Noel', 'Eve'].sample
-salary_increase_opt = compute_increase.(user) # None | Some(10000)
-
-salary_increase_opt.reduce(base_salary, &:+) # 20000 | 30000
-# is equivalent to
-salary_increase_opt.map{|increase| base_salary + increase} # None | Some(30000)
-                   .get_or_else(base_salary) # 20000 | 30000

data/docs/usage_snippet.rb

@@ -1,77 +0,0 @@
-require_relative '../test/test_helper' # IGNORE
-# IGNORE
-require 'test/unit' # IGNORE
-include Test::Unit::Assertions # IGNORE
-
-# You can create an option from any object `obj`
-# In general, any object gets wrapped into a `Some` instance
-some = Yopt::Option[42] # Some(42)
-# The only exception being `nil`, which turns into `None`
-none = Yopt::Option[nil] # None
-
-# since Some and None have the same API, let's choose one of the two
-# randomly, and record the intermediate result of each computation
-# for both None and Some(42) following the convention <result_if_none> | <result_if_some>
-opt = [none, some].sample
-
-opt                  # None | Some(42)
-  .select{|x| x > 0} # None | Some(42)
-  .map(&:succ)       # None | Some(43)
-  .get_or_else(1)    # 1    | 43
-
-# Calling select/reject on a Some instance can return None
-# Whereas a None can never be transformed into a Some
-                        # None | Some(42)
-opt.select{ |x| x < 0 } # None | None
-
-# One of the perks of working with options is that it allow us to stay
-# away from `nil` and `if` statements. You can still revert to using them if you need to though
-# There always is a better way to go though.
-opt.or_nil # nil | 42
-# Even better, if the option is None we can return a default value straight away
-opt.get_or_else 31 # 31 | 42
-
-# If we intend to stay in the Option domain for some more time we can swap None with an other Option
-opt.or_else(Yopt::Option[61]) # Some(61) | Some(42)
-   .reject(&:even?)           # Some(61) | None
-   .get_or_else 0             # 61       | 0
-
-# Once in the Option domain, it's nice to avoid accessing
-# the content of an option explicitly as far as possible.
-# You might eventually need to extract the value wrapped by
-# Option.
-begin     # None                  | Some(42)
-  opt.get # raises a RuntimeError | 42
-rescue RuntimeError
-  puts "cannot call #get on #{opt}"
-end
-
-# This does not look safe. Luckily we can check if the option
-# is None by calling `empty?` on it
-opt.empty? # true | false
-
-
-# v = s2.reduce(2){|default, opt_val| opt_val - default} # 47
-# n = Yopt::Some.new(v) # Some(47)
-#   .collect{|x| if x % 2 == 1 then x + 1 end} # None
-#   .map{|x| x ** 2} # None
-
-# if s1.reduce(s2.get, &:-) < 0 && s1.include?(42) # true
-#   s2.collect{ n.empty? && n } # Some(None)
-#     .flatten # None
-#     .or_nil # nil
-# end
-# head_opt = Util.lift &:first
-# old_school_validate = -> email {if email.end_with?('my-domain.com') then email else nil end}
-# valid = 'user@my-domain.com'
-# invalid = '@gmail.com'
-# old_school_validate.(invalid).must_equal nil
-# old_school_validate.(valid).wont_be_nil
-# old_school_validate.(valid).must_equal valid
-
-# brand_new_validate = Util.lift &old_school_validate
-# brand_new_validate.(invalid).must_equal None
-# brand_new_validate.(valid).must_equal Some.new(valid)
-
-# user = brand_new_validate.(valid) | Util.lift{|email| email.split('@')[0]} | :upcase
-# user.get.must_equal "USER"

data/docs/usage_zip.rb

@@ -1,30 +0,0 @@
-require_relative '../test/test_helper' # IGNORE
-# IGNORE
-require 'test/unit' # IGNORE
-include Test::Unit::Assertions # IGNORE
-
-validate_email = Yopt.lift {|x| x if x.end_with? "@domain.com"}
-validate_password = Yopt.lift {|x| x if x.size > 8}
-hash_f = lambda {|str| str.each_char.map(&:ord).reduce(:+)}
-
-# returns Yopt::Some(Fixnum) if email and password are both valid
-# returns Yopt::None otherwise
-hash_credentials = -> (email, password) do
-    maybe_email    = validate_email.(email)
-    maybe_password = validate_password.(password)
-
-    maybe_email.zip(maybe_password)
-               .map {|(valid_email, valid_pass)| hash_f.(valid_email + valid_pass)}
-end
-
-same_string( # IGNORE
-hash_credentials.('invalid_mail', 'valid_pass')
-).('None') # COMMENT
-# IGNORE
-same_string( # IGNORE
-hash_credentials.('valid@domain.com', 'invalid')
-).('None') # COMMENT
-# IGNORE
-same_string( # IGNORE
-hash_credentials.('valid@domain.com', 'valid_pass')
-).('Some(2651)') # COMMENT

data/yopt.gemspec

@@ -1,26 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'yopt/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "yopt"
-  spec.version       = Yopt::VERSION
-  spec.authors       = ["lorenzo.barasti"]
-
-  spec.summary       = %q{Scala-inspired Options for the idiomatic Rubyist}
-  spec.description   = %q{The Option type models the possible absence of a value. It lets us deal with the uncertainty related to such a value being there without having to resort to errors or conditional blocks.}
-  spec.homepage      = "http://lbarasti.github.io/yopt"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = '>= 2.0'
-
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest", "~> 5.8"
-end