lib/muina/maybe/some.rb in muina-0.6.0 vs lib/muina/maybe/some.rb in muina-0.7.0

@@ -1,67 +1,134 @@
+# typed: strict
 # frozen_string_literal: true
 
 module Muina
   class Maybe
+    # rubocop:disable Metrics/ClassLength
+
     class Some < self
+      class << self
+        undef_method :some
+        undef_method :none
+      end
+
+      Elem = type_member { { upper: Object } }
+      ElemT = type_template { { upper: Object } }
+
       private_class_method(:new)
+      sig { params(value: Elem).void }
       def initialize(value) # rubocop:disable Lint/MissingSuper
         @value = value
         freeze
       end
 
+      # (see Maybe#some?)
+      sig { override.returns T::Boolean }
       def some?
         true
       end
 
+      sig { override.returns T::Boolean }
+      # (see Maybe#none?)
       def none?
         false
       end
 
+      sig { override.returns Elem }
+      # (see Maybe#value!)
       def value!
         @value
       end
 
+      # (see Maybe#value_or)
+      sig do
+        override.type_parameters(:Default)
+                .params(_default: T.type_parameter(:Default))
+                .returns(T.any(Elem, T.type_parameter(:Default)))
+      end
       def value_or(_default)
         @value
       end
 
-      def value_or_yield
+      sig do
+        override.type_parameters(:T)
+                .params(_blk: T.proc.returns(T.type_parameter(:T)))
+                .returns(T.any(Elem, T.type_parameter(:T)))
+      end
+      # (see Maybe#value_or_yield)
+      def value_or_yield(&_blk)
         @value
       end
 
+      sig { override.returns(T.any(Elem, NilClass)) }
+      # (see Maybe#value_or_nil)
       def value_or_nil
         @value
       end
 
-      def and_then
+      sig { override.params(_blk: T.untyped).returns(T.self_type) }
+      # (see Maybe#and_then)
+      def and_then(&_blk)
         yield(@value)
         self
       end
 
-      def or_else
+      sig { override.params(_blk: T.untyped).returns(T.self_type) }
+      # (see Maybe#or_else)
+      def or_else(&_blk)
         self
       end
 
-      def map
+      sig do
+        override.type_parameters(:T)
+                .params(
+                  _blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:T))
+                )
+                .returns(T.any(Maybe[Elem], Maybe[T.type_parameter(:T)]))
+      end
+      # (see Maybe#map)
+      def map(&_blk)
         Maybe.return yield(@value)
       end
 
-      def map_none
+      sig do
+        override.type_parameters(:T)
+                .params(_blk: T.proc.returns(T.type_parameter(:T)))
+                .returns(T.any(Maybe[Elem], Maybe[T.type_parameter(:T)]))
+      end
+      # (see Maybe#map_none)
+      def map_none(&_blk)
         self
       end
 
-      def bind
+      sig do
+        override.type_parameters(:T)
+                .params(
+                  _blk: T.proc.params(arg0: Elem).returns(Maybe[T.type_parameter(:T)])
+                )
+                .returns(T.any(Maybe[Elem], Maybe[T.type_parameter(:T)]))
+      end
+      # (see Maybe#bind)
+      def bind(&_blk)
         yield(@value)
       end
 
-      def bind_none
+      sig do
+        override.type_parameters(:T)
+                .params(_blk: T.proc.returns(Maybe[T.type_parameter(:T)]))
+                .returns(T.any(Maybe[Elem], Maybe[T.type_parameter(:T)]))
+      end
+      # (see Maybe#bind_none)
+      def bind_none(&_blk)
         self
       end
 
+      sig { override.params(other: T.untyped).returns(T::Boolean) }
+      # (see Maybe#==)
       def ==(other)
         self.class == other.class &&
           value! == other.value!
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end