Module: Enumerable

Included in:
NRSER::Sys::Env::Path
Defined in:
lib/nrser/core_ext/enumerable.rb,
lib/nrser/core_ext/enumerable/find_map.rb,
lib/nrser/core_ext/enumerable/slash_map.rb

Overview

Instance methods to extend Enumerable.

Instance Method Summary collapse

Instance Method Details

#/(proc_able) ⇒ Enumerable

Note:

EXPERIMENTAL!

An idea I’m playing around with for convenient mapping of Enumerable.

Not so bad, eh? I’m calling it “slash-map” for the moment, BTW.

Examples:

Extract Attributes

Cat   = Struct.new :name, :breed

cats  = [ Cat.new( 'Hudie', 'Chinese-American Shorthair' ),
          Cat.new( 'Oscar', 'Bengal' ) ]

cats/:name  #=> [ 'Hudie', 'Oscar' ]
cats/:breed #=> [ 'Chinese-American Shorthair', 'Bengal' ]

Extract Values

# Need the array.to_proc ~> ->( key ) { array.dig *key } for it to really
# *feel* nice... and that's the whole point!
require 'nrser/core_ext/array/to_proc'

kitties = [ { name: 'Hootie' }, 
            { name: 'Oscie'  } ]

kitties/[:name] #=> [ 'Hooie', 'Oscie' ]

Parameters:

  • proc_able (#to_proc) —

    Something that can be ‘#to_proc`’d for the #map.

Returns:



33
34
35
 
# File 'lib/nrser/core_ext/enumerable/slash_map.rb', line 33

def / proc_able
  map &proc_able
end

#assoc_by(*args, &block) ⇒ Object

See NRSER.assoc_by



35
36
37
 
# File 'lib/nrser/core_ext/enumerable.rb', line 35

def assoc_by *args, &block
  NRSER.assoc_by self, *args, &block
end

#assoc_to(*args, &block) ⇒ Object

See NRSER.assoc_to



41
42
43
 
# File 'lib/nrser/core_ext/enumerable.rb', line 41

def assoc_to *args, &block
  NRSER.assoc_to self, *args, &block
end

#count_by(&block) ⇒ Object

See NRSER.count_by



65
66
67
 
# File 'lib/nrser/core_ext/enumerable.rb', line 65

def count_by &block
  NRSER.count_by self, &block
end

#enumerate_as_values ⇒ Object

See NRSER.enumerate_as_values



47
48
49
 
# File 'lib/nrser/core_ext/enumerable.rb', line 47

def enumerate_as_values
  NRSER.enumerate_as_values self
end

#find_bounded(bounds, &block) ⇒ Object

See NRSER.find_bounded



11
12
13
 
# File 'lib/nrser/core_ext/enumerable.rb', line 11

def find_bounded bounds, &block
  NRSER.find_bounded self, bounds, &block
end

#find_map(ifnone = nil, &block) ⇒ nil, ...

Find the first truthy (not ‘nil` or `false`) result of calling `&block` on entries.

Like #find, accepts an optional ‘ifnone` procedure to call if no match is found.

Examples:


[1, 2, 3, 4].find_map do |i|
  if i.even?
    "#{ i } is even!"
  end
end
# => "2 is even!"

Parameters:

  • ifnone (nil | Proc<()=>DEFAULT>) (defaults to: nil) —

    Optional lambda to call for the return value when no match is found.

  • block (Proc<(E)=>RESLUT>) —

    Block mapping entires to results.

Returns:

  • (nil) —

    When ‘block.call( E )` is `nil` or `false` for all entries `E` and `ifnone` is `nil` or not provided.

  • (V) —

    When ‘block.call( E )` is `nil` or `false` for all entries `E` and `ifnone` is a lambda that returns `DEFAULT`.

  • (RESULT) —

    The first result ‘RESLUT = block.call( E )` where `RESLUT` is not `nil` or `false`.

  • (DEFAULT) —

    When ‘ifnone` procedure is provided and `&block` returns `nil` or `false` for all entries.

  • (nil) —

    When ‘ifnone` procedure is not provided and `&block` returns `nil` or `false` for all entries.



44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/nrser/core_ext/enumerable/find_map.rb', line 44

def find_map ifnone = nil, &block
  each do |entry|
    if result = block.call( entry )
      # Found a match, short-circuit
      return result
    end
  end
  
  # No matches, return `ifnone`
  ifnone.call if ifnone
end

#find_only(&block) ⇒ Object

See NRSER.find_only



17
18
19
 
# File 'lib/nrser/core_ext/enumerable.rb', line 17

def find_only &block
  NRSER.find_only self, &block
end

#find_only!(&block) ⇒ Object

Right now, exactly the same as #find_only… though I wished I had called it this and had #find_only return ‘nil` if it failed, as is kind-of a some-what established practice, because now I get confused.

Maybe some day I will make that change. For now, this is here so when I forget and add the ‘!` it works.



29
30
31
 
# File 'lib/nrser/core_ext/enumerable.rb', line 29

def find_only! &block
  NRSER.find_only self, &block
end

#only(**options) ⇒ Object

Calls NRSER.only on ‘self`.



53
54
55
 
# File 'lib/nrser/core_ext/enumerable.rb', line 53

def only **options
  NRSER.only self, **options
end

#only! ⇒ Object

See NRSER.only!



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

def only!
  NRSER.only! self
end

#slice?(*args, &block) ⇒ Boolean

See NRSER.slice?

Returns:

  • (Boolean) 


77
78
79
 
# File 'lib/nrser/core_ext/enumerable.rb', line 77

def slice? *args, &block
  NRSER.slice? self, *args, &block
end

#try_find(&block) ⇒ Object

See NRSER.try_find



71
72
73
 
# File 'lib/nrser/core_ext/enumerable.rb', line 71

def try_find &block
  NRSER.try_find self, &block
end