Class: Array

Inherits:
Object show all
Includes:
NRSER::Ext::Tree
Defined in:
lib/nrser/core_ext/array.rb

Instance Method Summary collapse

Methods included from NRSER::Ext::Tree

#each_branch, #leaves, #map_branches, #map_leaves, #map_tree

Instance Method Details

#ellipsis(*args) ⇒ Object

Calls NRSER.ellipsis on ‘self`.



20
21
22
 
# File 'lib/nrser/core_ext/array.rb', line 20

def ellipsis *args
  NRSER.ellipsis self, *args
end

#extract!(&block) ⇒ Object 



14
15
16
 
# File 'lib/nrser/core_ext/array.rb', line 14

def extract! &block
  NRSER.extract_from_array! self, &block
end

#rest ⇒ Array

Returns new array consisting of all elements after the first (which may be none, resulting in an empty array).

Returns:

  • (Array) —

    new array consisting of all elements after the first (which may be none, resulting in an empty array).



9
10
11
 
# File 'lib/nrser/core_ext/array.rb', line 9

def rest
  NRSER.rest self
end

#to_chainer(publicly: true) ⇒ Object

See NRSER.chainer.



91
92
93
 
# File 'lib/nrser/core_ext/array.rb', line 91

def to_chainer publicly: true
  NRSER.chainer self, publicly: publicly
end

#to_digger ⇒ Proc

TODO:

I wanted to use ‘#to_proc` so that you could use `&[:id]`, but unary `&` doesn’t invoke refinements, and I don’t really want to monkey-patch anything, especially something as core as ‘#to_proc` and `Array`.

Returns a lambda that calls accepts a single arg and calls ‘#dig` on it with the elements of this array as arguments.

Examples:

list = [{id: 1, name: "Neil"}, {id: 2, name: "Mica"}]
list.assoc_by &[:id].to_digger
# =>  {
#       1 => {id: 1, name: "Neil"},
#       2 => {id: 2, name: "Mica"},
#     }

Returns:

  • (Proc) —

    Lambda proc that accepts a single argument and calls ‘#dig` with this array’s contents as the ‘#dig` arguments.



116
117
118
 
# File 'lib/nrser/core_ext/array.rb', line 116

def to_digger
  NRSER::Message.new( :dig, *self ).to_proc
end

#to_message ⇒ NRSER::Message Also known as: to_m

Creates a new NRSER::Message from the array.

Examples:


message = [:fetch, :x].to_message
message.send_to x: 'ex', y: 'why?'
# => 'ex'

Returns:



59
60
61
 
# File 'lib/nrser/core_ext/array.rb', line 59

def to_message
  NRSER::Message.new *self
end

#to_pair ⇒ Array

Checks that length is 2 and returns ‘self`.

Returns:

  • (Array) —

    Array of length 2.

Raises:

  • (TypeError) —

    If length is not 2.



36
37
38
39
40
41
42
43
 
# File 'lib/nrser/core_ext/array.rb', line 36

def to_pair
  unless length == 2
    raise TypeError,
          "Array is not of length 2: #{ self.inspect }"
  end
  
  self
end

#to_sender(publicly: true) ⇒ Proc

Create a Proc that accepts a single ‘receiver` and provides this array’s entries as the arguments to ‘#public_send` (or `#send` if the `publicly` option is `false`).

Equivalent to

to_message.to_proc publicly: boolean

Examples:


[:fetch, :x].sender.call x: 'ex'
# => 'ex'

Parameters:

  • publicly: (Boolean) (defaults to: true) —

    When ‘true`, uses `#public_send` in liu of `#send`.

Returns:

  • (Proc) 


84
85
86
 
# File 'lib/nrser/core_ext/array.rb', line 84

def to_sender publicly: true
  to_message.to_proc publicly: publicly
end