Module: Curry

Extended by:
Curry
Included in:
Curry
Defined in:
lib/curry.rb

Instance Method Summary collapse

Instance Method Details

#add ⇒ Object

operators



110
 
# File 'lib/curry.rb', line 110

def add; lambda { |a, b| a + b }; end

#all ⇒ Object 



105
 
# File 'lib/curry.rb', line 105

def all; lambda { |func, xs| xs.select(&func).size == xs.size }; end

#any ⇒ Object 



106
 
# File 'lib/curry.rb', line 106

def any; lambda { |func, xs| xs.select(&func).size > 0 }; end

#collect ⇒ Object

synonyms



94
 
# File 'lib/curry.rb', line 94

def collect; map; end

#count ⇒ Object 



80
 
# File 'lib/curry.rb', line 80

def count; lambda { |func, xs| xs.count(&func) }; end

#cycle ⇒ Object 



81
 
# File 'lib/curry.rb', line 81

def cycle; lambda { |func, xs| xs.cycle(&func) }; end

#cyclen ⇒ Object 



82
 
# File 'lib/curry.rb', line 82

def cyclen; lambda { |func, n, xs| xs.cycle(n, &func) }; end

#delete_if ⇒ Object 



85
 
# File 'lib/curry.rb', line 85

def delete_if; lambda { |func, xs| xs.delete(&func) }; end

#div ⇒ Object 



113
 
# File 'lib/curry.rb', line 113

def div; lambda { |a, b| a / b }; end

#drop_while ⇒ Object 



86
 
# File 'lib/curry.rb', line 86

def drop_while; lambda { |func, xs| xs.drop_while(&func) }; end

#each ⇒ Object 



72
 
# File 'lib/curry.rb', line 72

def each; lambda { |func, xs| xs.each(&func) }; end

#each_index ⇒ Object 



79
 
# File 'lib/curry.rb', line 79

def each_index; lambda { |func, xs| xs.each_index(&func) }; end

#eql ⇒ Object 



115
 
# File 'lib/curry.rb', line 115

def eql; lambda { |a, b| a == b }; end

#even ⇒ Object 



120
 
# File 'lib/curry.rb', line 120

def even; lambda { |a| a % 2 == 0 }; end

#fill ⇒ Object 



73
 
# File 'lib/curry.rb', line 73

def fill; lambda { |func, xs| xs.fill(&func) }; end

#filter ⇒ Object 



102
 
# File 'lib/curry.rb', line 102

def filter; select; end

#fnot ⇒ Object 



122
 
# File 'lib/curry.rb', line 122

def fnot; lambda { |a| !a }; end

#foldl ⇒ Object 



30
31
32
33
34
35
36
37
 
# File 'lib/curry.rb', line 30

def foldl
  lambda do |func, acc, xs|
    xs.each do |x|
      acc = func.call(acc, x)
    end
    acc
  end
end

#foldl1 ⇒ Object 



40
41
42
43
44
45
46
47
48
49
 
# File 'lib/curry.rb', line 40

def foldl1
  lambda do |func, xs|
    acc = nil
    xs.each do |x|
      next acc = x unless acc
      acc = func.call(acc, x)
    end
    acc
  end
end

#foldr ⇒ Object 



51
52
53
54
55
56
57
58
 
# File 'lib/curry.rb', line 51

def foldr
  lambda do |func, acc, xs|
    xs.reverse.each do |x|
      acc = func.call(acc, x)
    end
    acc
  end
end

#foldr1 ⇒ Object 



60
61
62
63
64
65
66
67
68
69
 
# File 'lib/curry.rb', line 60

def foldr1
  lambda do |func, xs|
    acc = nil
    xs.reverse_each do |x|
      next acc = x unless acc
      acc = func.call(acc, x)
    end
    acc
  end
end

#fp ⇒ Object 



90
 
# File 'lib/curry.rb', line 90

def fp; lambda { |x| p x }; end

#fprint ⇒ Object 



91
 
# File 'lib/curry.rb', line 91

def fprint; lambda { |x| print x }; end

#fputs ⇒ Object 



89
 
# File 'lib/curry.rb', line 89

def fputs; lambda { |x| puts x }; end

#gt ⇒ Object 



116
 
# File 'lib/curry.rb', line 116

def gt; lambda { |a, b| b > a }; end

#gte ⇒ Object 



117
 
# File 'lib/curry.rb', line 117

def gte; lambda { |a, b| b >= a }; end

#index ⇒ Object 



76
 
# File 'lib/curry.rb', line 76

def index; lambda { |func, xs| xs.index(&func) }; end

#inject ⇒ Object 



96
 
# File 'lib/curry.rb', line 96

def inject; foldl; end

#inject1 ⇒ Object 



99
 
# File 'lib/curry.rb', line 99

def inject1; foldl1; end

#lt ⇒ Object 



118
 
# File 'lib/curry.rb', line 118

def lt; lambda { |a, b| b < a }; end

#lte ⇒ Object 



119
 
# File 'lib/curry.rb', line 119

def lte; lambda { |a, b| b <= a }; end

#map ⇒ Object 



71
 
# File 'lib/curry.rb', line 71

def map; lambda { |func, xs| xs.map(&func) }; end

#mul ⇒ Object 



112
 
# File 'lib/curry.rb', line 112

def mul; lambda { |a, b| a * b }; end

#odd ⇒ Object 



121
 
# File 'lib/curry.rb', line 121

def odd; lambda { |a| !even[a] }; end

#permutation ⇒ Object 



78
 
# File 'lib/curry.rb', line 78

def permutation; lambda { |func, xs| xs.permutation(&func) }; end

#pow ⇒ Object 



114
 
# File 'lib/curry.rb', line 114

def pow; lambda { |a, b| a ** b }; end

#reduce ⇒ Object 



97
 
# File 'lib/curry.rb', line 97

def reduce; inject; end

#reduce1 ⇒ Object 



100
 
# File 'lib/curry.rb', line 100

def reduce1; inject1; end

#reject ⇒ Object 



77
 
# File 'lib/curry.rb', line 77

def reject; lambda { |func, xs| xs.reject(&func) }; end

#select ⇒ Object 



75
 
# File 'lib/curry.rb', line 75

def select; lambda { |func, xs| xs.select(&func) }; end

#sort ⇒ Object 



74
 
# File 'lib/curry.rb', line 74

def sort; lambda { |func, xs| xs.sort(&func) }; end

#sub ⇒ Object 



111
 
# File 'lib/curry.rb', line 111

def sub; lambda { |a, b| a - b }; end

#take_while ⇒ Object 



87
 
# File 'lib/curry.rb', line 87

def take_while; lambda { |func, xs| xs.take_while(&func) }; end

#to_m(name, funcname) ⇒ Object

converting a proc to a method



126
127
128
 
# File 'lib/curry.rb', line 126

def to_m(name, funcname)
  eval("def #{name}(*args); #{funcname}[*args]; end")
end

#zip ⇒ Object 



83
 
# File 'lib/curry.rb', line 83

def zip; lambda{ |func, xs, ys| xs.zip(ys, &func) }; end

#zipWith ⇒ Object 



103
 
# File 'lib/curry.rb', line 103

def zipWith; zip; end