daitai 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b580a7ada3ae9b6b21a4c8cc3aaa6768cbca06f267081dd2c53e8da0db8b82d0
-  data.tar.gz: 495f5ed0f52a58a53247fae9d2f41795b915b7f33b4d60a530f203bea681eb82
+  metadata.gz: '09d2dfb7f123eb7f0213eaf438aae0f88336afafd58416a66790751fb241978d'
+  data.tar.gz: 4d19c1d0ff42be462e63eba58c503f13d247bc3176b1514d54eed3a6b2512542
 SHA512:
-  metadata.gz: 5f708096ff66b8c837fe24bc24b0a41b4373ca9bcc85c7280fdec9ffb4b8967a2161bfdddaa3354cea01ff5bcf103a156371b839a396dbc28df7e778f4c0d9ba
-  data.tar.gz: 3a7836b2adddc9ec27fa54261303996fe3f0999067bc8f6682123ae73983cc901d626c66643c8a369a08a13184a3395e8dfa01b4932daed1ae3b2a1146c8efdd
+  metadata.gz: 2dab3b9141d8c25e5bcf8fe97d3c3e62d9fa614c6774776ac98d21780f2c031701df1fb379804c3ff9c466e0a354a1e3c4bf7b2f2ef9760dd50ed90c2e33ab00
+  data.tar.gz: ad94909fa77456c515db956c74e99a74958cbd7db2b97c9b96df3ef96adf4f6033a55459f4d4a3ff4b31411331df14dfd1a62a98a458245f5b11d9efd649d562

data/.rubocop.yml

@@ -13,3 +13,6 @@ Metrics/LineLength:
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*'
+
+AllCops:
+  TargetRubyVersion: 2.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    daitai (0.1.5)
+    daitai (0.1.6)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -14,19 +14,19 @@ Daitai (代替, Japanese for "alternative") is a functional library for Ruby lan
 
 Add this line to your application's Gemfile:
 
-```ruby
+```bash
 gem 'daitai'
 ```
 
 And then execute:
 
-```
+```bash
 $ bundle
 ```
 
 Or install it yourself as:
 
-```
+```bash
 $ gem install daitai
 ```
 
@@ -58,6 +58,8 @@ $ gem install daitai
 * [reverse](#reverse-definition)
 * [signum](#signum-definition)
 * [sort](#sort-definition)
+* [sort_by](#sort_by-definition)
+* [sort_with](#sort_with-definition)
 * [subtract](#subtract-definition)
 * [sum](#sum-definition)
 * [tail](#tail-definition)
@@ -181,6 +183,7 @@ Returns a list of all elements that satisfy the predicate.
 ```ruby
 greater_than_two = ->(x) { x > 2 }
 Daitai.filter.(greater_than_two, [1, 2, 3, 4]) # => [3, 4]
+Daitai.filter.(greater_than_two, x: 2, y: 3, z: 5) # => { y: 3, z: 5 }
 
 only_even = Daitai.filter.(->(x) { x % 2 == 0 })
 only_even.([1, 2, 3, 4]) # => [2, 4]
@@ -249,6 +252,7 @@ Applies the function to all elements of the list and returns a new list of the r
 ```ruby
 triple = ->(x) { x * 3 }
 Daitai.map.(triple, [1, 2, 3, 4]) # => [3, 6, 9, 12]
+Daitai.map.(triple, a: 10, b: 13) # => { a: 30, b: 39 }
 
 increment = Daitai.map.(->(x) { x + 1 })
 increment.([1, 2, 3, 4]) # => [2, 3, 4, 5]
@@ -392,6 +396,9 @@ Reduces the list using the function, from left to right, using the accumulator.
 add = ->(x, y) { x + y }
 Daitai.reduce.(add, 0, [1, 2, 3, 4]) # => 10
 
+sum = ->(acc, (_, v)) { v + acc }
+Daitai.reduce.(sum, 0, x: 2, y: 3, z: 5) # => 10
+
 concat = Daitai.reduce.(add, "")
 concat.(%w[l a m b d a]) # => "lambda"
 ```
@@ -426,7 +433,38 @@ Daitai.signum.(-8) # => -1
 - - -
 
 <h4 id='sort-definition'>
-  <code>sort :: (a -> a -> Numeric) -> [a] -> [a]</code>
+  <code>sort :: [a] -> [a]</code>
+</h4>
+
+Returns a copy of the list sorted in the ascending order.
+
+```ruby
+Daitai.sort.(diff, [2, 1, 4, 3]) # => [1, 2, 3, 4]
+Daitai.sort.(%w[haskell ruby elixir]) # => ["elixir", "haskell", "ruby"]
+```
+
+- - -
+
+<h4 id='sort_by-definition'>
+  <code>sort_by :: a -> [a] -> [a]</code>
+</h4>
+
+Returns a copy of the list sorted by the provided property - either a key of a `Hash` or a name of an `Object`'s function.
+
+```ruby
+apple  = { colour: 'red',    weight: 136 }
+banana = { colour: 'yellow', weight: 118 }
+pear   = { colour: 'green',  weight: 178 }
+Daitai.sort_by.(:weight, [apple, banana, pear]) # => [banana, apple, pear]
+
+sort_by_length = Daitai.sort_by.(:length)
+sort_by_length.(%w[haskell ruby elixir] # => ["ruby", "elixir", "haskell"]
+```
+
+- - -
+
+<h4 id='sort_with-definition'>
+  <code>sort_with :: (a -> a -> Numeric) -> [a] -> [a]</code>
 </h4>
 
 Returns a sorted copy of the list according to the specified comparator function.

data/lib/daitai.rb

@@ -30,6 +30,8 @@ module Daitai
   extend Reverse
   extend Signum
   extend Sort
+  extend SortBy
+  extend SortWith
   extend Subtract
   extend Sum
   extend Tail

data/lib/daitai/abs.rb

@@ -3,7 +3,7 @@
 module Daitai
   module Abs
     def abs
-      ->(x) { x < 0 ? -x : x }
+      ->(x) { x < 0 ? -x : x } # rubocop:disable Style/NumericPredicate
     end
   end
 end

data/lib/daitai/compose.rb

@@ -3,25 +3,9 @@
 module Daitai
   module Compose
     def compose
-      lambda do |*functions|
-        if functions.length > 2
-          compose_n(functions)
-        else
-          compose_two(functions)
-        end
+      lambda do |f, g|
+        ->(*args) { f.(g.(*args)) }
       end.curry
     end
-
-    private
-
-    def compose_two(functions)
-      f, g = functions
-      ->(*args) { f.(g.(*args)) }
-    end
-
-    def compose_n(functions)
-      head, *tail = functions
-      ->(*args) { head.(compose.(*tail).(*args)) }
-    end
   end
 end

data/lib/daitai/pipe.rb

@@ -3,25 +3,9 @@
 module Daitai
   module Pipe
     def pipe
-      lambda do |*functions|
-        if functions.length > 2
-          pipe_n(functions)
-        else
-          pipe_two(functions)
-        end
+      lambda do |f, g|
+        ->(*args) { g.(f.(*args)) }
       end.curry
     end
-
-    private
-
-    def pipe_two(functions)
-      f, g = functions
-      ->(*args) { g.(f.(*args)) }
-    end
-
-    def pipe_n(functions)
-      head, *tail = functions
-      ->(*args) { pipe.(*tail).(head.(*args)) }
-    end
   end
 end

data/lib/daitai/sort.rb

@@ -3,9 +3,7 @@
 module Daitai
   module Sort
     def sort
-      lambda do |comparator, list|
-        list.sort(&comparator)
-      end.curry
+      ->(sortable) { sortable.sort }
     end
   end
 end

data/lib/daitai/sort_by.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Daitai
+  module SortBy
+    def sort_by
+      lambda do |property, sortable|
+        comparator = sort_elements(property)
+        sortable.sort_by(&comparator)
+      end.curry
+    end
+
+    private
+
+    def sort_elements(property)
+      lambda do |object|
+        case object
+        when Hash then object[property]
+        else object.send(property)
+        end
+      end
+    end
+  end
+end

data/lib/daitai/sort_with.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Daitai
+  module SortWith
+    def sort_with
+      lambda do |comparator, sortable|
+        sortable.sort(&comparator)
+      end.curry
+    end
+  end
+end

data/lib/daitai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Daitai
-  VERSION = '0.1.5'.freeze
+  VERSION = '0.1.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: daitai
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Walerian Sobczak
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-17 00:00:00.000000000 Z
+date: 2018-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,6 +114,8 @@ files:
 - lib/daitai/reverse.rb
 - lib/daitai/signum.rb
 - lib/daitai/sort.rb
+- lib/daitai/sort_by.rb
+- lib/daitai/sort_with.rb
 - lib/daitai/subtract.rb
 - lib/daitai/sum.rb
 - lib/daitai/tail.rb