serradura/kind

A development toolkit for Ruby with several small/cohesive abstractions to empower your development workflow - It's totally free of dependencies.

kind's Issues

Kind::Types.add() must know how to handle types with namespaces

If the name option was omitted and the type has a namespace, the type checker will have the same namespace. e.g: Kind::Types.add(Account::User) will generate Kind.of.Account::User(value)/Kind.is.Account::User(value).

require "kind/of/stdlib"

Implement type checkers for the data types available in the stdlib like: Date, StringIO, Set, OpenStruct

Add Kind::Of(Type) to create type checkers and add a deprecation warning for Kind.of(Type)

In the v4 Kind.of(<Type>, value) will only be used to check and raise an exception if the given value hasn't the expected type. So, Kind::Of(Type) will be the new way to build type checkers.

Kind.of.<Type>.as_optional()

Scope:

• .as_optional/as_maybe must be available for any [type checker].(https://github.com/serradura/kind/blob/b177fed9cc2b3347d63963a2a2fd99f989c51a9a/README.md#type-checkers)
  • Return a lambda when these methods were called without an argument.

Concept:

person_name method

data = {first_name: 'Rodrigo', last_name: 'Rodrigues'}

def person_name1(data)
  "#{data[:first_name]} #{data[:last_name]}"
end

def person_name2(data)
  data = Kind.of.Hash(data)

  "#{data[:first_name]} #{data[:last_name]}"
end

def person_name3(data)
  Kind::Optional[data].
    then { |data| "#{data[:first_name]} #{data[:last_name]}" }.
    value_or { 'John Doe' }
end

def person_name4(arg)
  hash = Kind.of.Hash.or_nil(arg)

  Kind::Optional[hash].
    then { |data| "#{data[:first_name]} #{data[:last_name]}" }.
    value_or { 'John Doe' }
end

def person_name5(arg)
  return 'John Doe' unless arg.is_a?(Hash)

  "#{data[:first_name]} #{data[:last_name]}"
end

Expectation:

def person_name5(arg)
  Kind::Of::Hash.as_optional(arg)
                .map { |data| "#{data[:first_name]} #{data[:last_name]}" }
                .value_or { 'John Doe' }
end

PersonIntroduction module

data = {first_name: 'Rodrigo', last_name: 'Rodrigues'}

module PersonIntroduction1
  extend self

  def call(data)
    "Hi my name is #{full_name(data)}, I'm #{age(data)}"
  end

  private

    def full_name(data)
      case data
      when Hash then "#{data[:first_name]} #{data[:last_name]}"
      else 'John Doe'
      end
    end

    def age(data)
      case data
      when Hash then data.fetch(:age, 0)
      else 0
      end
    end
end

module PersonIntroduction2
  extend self

  def call(data)
    "Hi my name is #{full_name(data)}, I'm #{age(data)}"
  end

  private

    def full_name(data)
      return 'John Doe' unless data.is_a?(Hash)

      "#{data[:first_name]} #{data[:last_name]}"
    end

    def age(data)
      data.is_a?(Hash) ? data.fetch(:age, 0) : 0
    end
end

module PersonIntroduction3
  extend self

  def call(arg)
    data = Kind::Optional[Kind.of.Hash.or_nil(arg)]

    "Hi my name is #{full_name(data)}, I'm #{age(data)}"
  end

  private

    def full_name(optional)
      optional.map { |data| "#{data[:first_name]} #{data[:last_name]}" }.
              value_or { 'John Doe' }
    end

    def age(optional)
      optional.map { |data| data[:age] }.
              value_or(0)
    end
end

Expectation:

module PersonIntroduction3
  extend self

  def call(arg)
    data = Kind::Of::Hash.as_optional(arg)

    "Hi my name is #{full_name(data)}, I'm #{age(data)}"
  end

  private

    def full_name(optional)
      optional.map { |data| "#{data[:first_name]} #{data[:last_name]}" }
              .value_or { 'John Doe' }
    end

    def age(optional)
      optional.map { |data| data[:age] }
              .value_or(0)
    end
end

Kind::Maybe.wrap { input.do_something! }

Create a method to build maybe objects which will avoid exceptions (returning Kind::None) if some error happened inside of the given block.

Kind::Types.add() must allow defining a custom name for the type checkers

Kind::Types.add(Queue, name: "Queue") will generate Kind.of.Queue/Kind.is.Queue()

Implement Kind.of.Callable

Type checker that verifies if a given object responds to the call method.

Add Kind::Some, Kind::None and Kind.of.Numeric.instance?(*args) (Kind.of.<Type>?)

New Features

Add = -> params do
  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)

  return Kind::None unless Kind.of.Numeric.instance?(a, b)

  Kind::Some(a + b)
end

# --

Kind::Optional.new(a: 1, b: 2).then(&Add).value_or(0) # 3

# --

Kind::Optional.new([]).then(&Add).value_or(0) # 0
Kind::Optional.new({}).then(&Add).value_or(0) # 0
Kind::Optional.new(nil).then(&Add).value_or(0) # 0

Improve Kind::Maybe example

Add = -> params do
  a, b = Kind.of.Hash(params, or: Empty::HASH).values_at(:a, :b)

  a + b if Kind.of.Numeric?(a, b)  
end

# --

Kind::Optional.new(a: 1, b: 2).then(&Add).value_or(0) # 3

# --

Kind::Optional.new([]).then(&Add).value_or(0) # 0
Kind::Optional.new({}).then(&Add).value_or(0) # 0
Kind::Optional.new(nil).then(&Add).value_or(0) # 0

Deprecate Kind.of(Type, value)

Related with #38

Remove the register of types

Remove Kind::Types.add() and all of Kind.of.<Type> checkers.

Implement Kind::Array::Of(<Type>)

1. Kind::Array::Of(Type) will create a callable that will verify if a given value is an array containing items with the expected type.
2. Kind::Array.of(String, value) will raise Kind::Error when the given value wasn't an array containing items with the expected type.
3. Kind::Array.of?(String, value) will return true when the given value be an array containing items with the expected type.

Kind::Result (implement the Either monad)

Kind::Success() or Kind::Failure()

module FindUser
  CreateByIdFinder = -> (repository:) do
    lambda do |id:|
      user = repository.find_by(id: id)
  
      return Kind::Success(user: user) if user
  
      Kind::Failure(:user_not_found)
    end 
  end

  ById = CreateByIdFinder.(repository: User)
end

Kind::Result#{on_success,on_failure} hooks

FindUser::ById.(user_id: 1)
  .on_success { |result| p result }
  .on_failure { |reason| p reason }

Kind::Result#{then,map} will perform only if the result was a success

FindUser::ById.(user_id: 1)
  .then { |result| p result }

# or

FindUser::ById.(user_id: 1)
  .map { |result| p result }

Implement Kind::Hash.with(<spec>)

Kind::Hash.with(
  name: String,
  age: Integer,
  handler: Kind::RespondTo(:call)
)