optionil 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 474500fa83542c00beb133857cee7e313f69b2b438f34e71fdf7a951d0817812
+  data.tar.gz: 1666195eab82be90d11e36b150b6dd3859238ea7f3c974a1859fe40a025ff0bd
+SHA512:
+  metadata.gz: 4d6186ddf704f47760efe275ce8246e38db9ac1018e0915d8dbde855b3c90bb8504bcc0cd4678b6a9701f4eea733a7e050e8c32ffe3ad0ffbadcc40856fbc89b
+  data.tar.gz: 3844681c0d3f6a6d7332236d0c83cb98d6f1a0c52c0150023bb69a627d6723fa71a17300c5824f649e03afb7e65ee13bee1d9211c478f21c3b7014c366582c17

data/LICENSE.txt

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

data/README.md

@@ -0,0 +1,104 @@
+This is an extremely simplistic (lol, only the 4 essential files) library that adds the Optional (anti)[^A] design pattern too ALL methods globally.
+It even supports [logic operators (`and`, `or`, etc.)](#logic-operation)!
+
+
+## Synopsis
+```ruby
+some = Optionil[42]        #=> Optionil::Some[42]
+none = Optionil[nil]       #=> Optionil::None[] (you don't want Optionil::Some[nil], do you?…)
+       Optionil::Some[nil] #!> NoMatchingPatternError (Do you???)
+none.equal? Optionil[]     #=> true (the two are equivalent and all calls give the same constant)
+
+Optionil::Some[]    #!> wrong number of arguments (given 0, expected 1) (ArgumentError)
+Optionil::None[nil] #!> wrong number of arguments (given 1, expected 0) (ArgumentError)
+```
+
+### Accessing
+```ruby
+some.value #=> some
+none.value #=> nil
+
+some.value! #=> 42
+none.value! #!> NoMatchingPatternError
+
+some.value {      0      } # => some
+some.value {    raise    } # => some
+none.value {      0      } # => 0
+none.value { Optionil[0] } # => Optionil::Some[0]
+
+some.each {|n|     -n       } #=> -42
+some.each {|n| Optionil[-n] } #=> Optionil::Some[-42]
+none.each {|n|     -n       } #=> nil
+none.each {|n|   raise      } #=> nil
+```
+
+### Pattern Matching
+```ruby
+Optionil       === some #=> true
+Optionil       === none #=> true
+Optionil::Some === some #=> true
+Optionil::Some === none #=> false
+Optionil::None === some #=> false
+Optionil::None === none #=> true
+
+some.some? #=> true
+none.some? #=> false
+some.none? #=> false
+none.none? #=> true
+
+some.some? Integer #=> true
+some.some? String  #=> false
+none.some? Integer #=> false
+
+some.some? &:even? #=> true
+some.some? &:odd?  #=> false
+some.none? &:even? #=> false
+some.none? &:odd?  #=> true
+```
+
+### Logic Operation
+```ruby
+!some #=> false
+!none #=> true
+
+som2 = Optionil::Some[-69]
+
+some and som2 #=> som2
+some and none #=> none
+none and som2 #=> none
+
+some or som2 #=> some
+some or none #=> some
+none or som2 #=> som2
+none or none #=> none
+
+som0 = Optional::Some[false]
+!som0 #=> true
+som0 and some #=> som0
+# applies to `Optional::Some[nil]` as well
+```
+
+### Method chaining
+I’m intentionally *not* supporting this.
+Please tune in to pipeine operator discussions instead, such as https://bugs.ruby-lang.org/issues/20770.
+
+
+## License
+Copyright © 2024 ParadoxV5
+
+I made this little joke as entertainment in a day.
+I release it to the public domain; you can redistribute it and/or modify it under the “terms” of the
+[Do What The Fuck You Want To Public License, Version 2](http://www.wtfpl.net/).
+
+[^A]: Cold take: the Optional pattern only exists because you can’t properlly handle `nil`s.
+    
+    Yes, `null` is a billion-dollar mistake in traditional languages; but this is Ruby – we don’t have `null`s, we have `nil`s!
+    A `String` can never be `nil`, only a `String?` (RBS) can!
+    
+    Even for, say Java, `NonNull` exists
+    ([JetBrains](https://www.jetbrains.com/help/idea/annotating-source-code.html#nullability-annotations),
+    [Android](https://developer.android.com/reference/androidx/annotation/NonNull),
+    [Lombok](https://projectlombok.org/features/NonNull)),
+    so nullable variables are already `Some|None` Schrödinger boxes, why bother adding `Option` as another layer of wrapper?
+    You’d think `Optional[T]?` wouldn’t be a thing? Do you need `Optional[Optional[T]]` for that?
+    JavaScript already has both `null` and `undefined`, questionably, yet how many *more* types of `nil`s do you still need?

data/lib/optionil.rb

@@ -0,0 +1,38 @@
+Optionil = Object
+class Optionil
+  def self.[](x = nil)
+    x
+  end
+  # {Some} is actually not a class. Take 1 arg
+  def (Some = ->{ !_1.nil? }).[](x)
+    case x
+    in self
+      x
+    end
+  end
+  # Take 0 args
+  # @return [nil]
+  def (None = NilClass).[]
+  end
+  
+  def value(&blk)
+    nil? ? blk&.() : self
+  end
+  def value!
+    Some[self]
+  end
+  def each(&blk)
+    if blk
+      blk.(self) unless nil?
+    else
+      enum_for __callee__
+    end
+  end
+  
+  def some?(matcher = nil, &blk)
+    (matcher.nil? ? blk || Some : matcher) === self
+  end
+  def none?(...)
+    !some?(...)
+  end
+end

data/optionil.gemspec

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do|spec|
+  spec.name = 'optionil'
+  spec.summary = 'Automatically apply the Optional pattern to all APIs globally, including the Ruby Corelib!'
+  spec.version = '1.0.1'
+  spec.author = 'ParadoxV5'
+  spec.license = 'WTFPL'
+  
+  github = "https://github.com/#{spec.author}/ruby-#{spec.name}"
+  spec.metadata = {
+    'homepage_uri'      => spec.homepage = github,
+    'changelog_uri'     => File.join(github, 'commits'),
+    'bug_tracker_uri'   => File.join(github, 'discussions'),
+  }
+  
+  spec.files = Dir['**/*']
+  spec.required_ruby_version = '>= 2.7'
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: optionil
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- ParadoxV5
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-11-11 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/optionil.rb
+- optionil.gemspec
+homepage: https://github.com/ParadoxV5/ruby-optionil
+licenses:
+- WTFPL
+metadata:
+  homepage_uri: https://github.com/ParadoxV5/ruby-optionil
+  changelog_uri: https://github.com/ParadoxV5/ruby-optionil/commits
+  bug_tracker_uri: https://github.com/ParadoxV5/ruby-optionil/discussions
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key:
+specification_version: 4
+summary: Automatically apply the Optional pattern to all APIs globally, including
+  the Ruby Corelib!
+test_files: []