ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/extra166y/Ops.java
Revision: 1.8
Committed: Sun Jan 18 20:17:32 2015 UTC (9 years, 3 months ago) by jsr166
Branch: MAIN
Changes since 1.7: +1 -0 lines
Log Message: 
exactly one blank line before and after package statements

File Contents

# User Rev Content
1 dl 1.1 /*
2     * Written by Doug Lea with assistance from members of JCP JSR-166
3     * Expert Group and released to the public domain, as explained at
4 jsr166 1.3 * http://creativecommons.org/publicdomain/zero/1.0/
5 dl 1.1 */
6    
7     package extra166y;
8 jsr166 1.8
9 dl 1.1 import java.util.*;
10    
11     /**
12     * Interfaces and utilities declaring per-element operations used
13     * within parallel methods on aggregates. This class provides type
14     * names for all operation signatures accepting zero, one or two
15     * arguments, and returning zero or one results, for parameterized
16 jsr166 1.6 * types, as well as specializations to {@code int}, {@code long},
17     * and {@code double}. In keeping with normal Java evaluation rules
18     * that promote, for example {@code short} to {@code int}, operation
19 dl 1.1 * names for these smaller types are absent.
20     *
21     * <p><b>Preliminary release note: Some of the declarations in this
22     * class are likely to be moved elsewhere in the JDK libraries
23     * upon actual release, and most likely will not all nested in the
24     * same class.</b>
25     *
26     * <p>The naming conventions are as follows:
27     * <ul>
28     *
29     * <li> The name of the single method declared in each interface is
30 jsr166 1.6 * simply {@code op} (short for "operate").
31 dl 1.1 *
32 jsr166 1.6 * <li> An {@code Op} (short for "operation") maps a single argument to
33 dl 1.1 * a result. Example: negating a value.
34     *
35     * <li> The names for scalar ops accepting and returning the same type
36     * are prefaced by their type name.
37     *
38 jsr166 1.6 * <li> A {@code BinaryOp} maps two arguments to a result. Example:
39 dl 1.1 * dividing two numbers
40     *
41 jsr166 1.6 * <li>A {@code Reducer} is an <em>associative</em> binary op
42 dl 1.1 * accepting and returning values of the same type; where op(a, op(b,
43     * c)) should have the same result as op(op(a, b), c). Example:
44     * adding two numbers.
45     *
46     * <li> Scalar binary ops accepting and returning the same type
47     * include their type name.
48     *
49     * <li> Mixed-type operators are named just by their argument type
50     * names.
51     *
52 jsr166 1.6 * <li> A {@code Generator} takes no arguments and returns a result.
53 dl 1.1 * Examples: random number generators, builders
54     *
55 jsr166 1.6 * <li> A {@code Procedure} accepts an argument but doesn't return a
56     * result. Example: printing a value. An {@code Action} is a
57 dl 1.1 * Procedure that takes no arguments.
58     *
59 jsr166 1.6 * <li>A {@code Predicate} accepts a value and returns a boolean indicator
60 dl 1.1 * that the argument obeys some property. Example: testing if a number is even.
61     *
62 jsr166 1.6 * <li>A {@code BinaryPredicate} accepts two values and returns a
63 dl 1.1 * boolean indicator that the arguments obeys some relation. Example:
64     * testing if two numbers are relatively prime.
65     *
66     * <li>Scalar versions of {@link Comparator} have the same properties
67     * as the Object version -- returning negative, zero, or positive
68     * if the first argument is less, equal, or greater than the second.
69     *
70     * </ul>
71     *
72     * <table border=1 cellpadding=0 cellspacing=0 > <caption>result = op(a) or
73     * result = op(a,b)</caption>
74     * <tr>
75     * <td >
76     * <td >
77     * <td >
78     * <td >
79     * <td >
80     * <td >
81     * <td >
82     * <td >
83     * <tr>
84     * <td >
85     * <th colspan=2 >arg types
86     * <th colspan=4 >result type
87     * <td >
88     * <tr>
89     * <td >
90     * <th >a
91     * <th >b
92 jsr166 1.6 * <th >{@code int}
93     * <th >{@code long}
94     * <th >{@code double}
95 dl 1.1 * <th >Object
96     * <td >
97     * <tr>
98     * <td >
99     * <td >
100     * <td >
101     * <td >
102     * <td >
103     * <td >
104     * <td >
105     * <td >
106     * <tr>
107     * <td >
108 jsr166 1.6 * <td >{@code int}
109 dl 1.1 * <td ><em>&lt;none&gt;</em>
110     * <td ><a href="Ops.IntOp.html">Ops.IntOp</a>
111     * <td ><a href="Ops.IntToLong.html">Ops.IntToLong</a>
112     * <td ><a href="Ops.IntToDouble.html">Ops.IntToDouble</a>
113     * <td ><a href="Ops.IntToObject.html">Ops.IntToObject</a>
114     * <td >
115     * <tr>
116     * <td >
117     * <td >
118 jsr166 1.6 * <td >{@code int}
119 dl 1.1 * <td ><a href="Ops.BinaryIntOp.html">Ops.BinaryIntOp</a>
120     * <td ><a href="Ops.IntAndIntToLong.html">Ops.IntAndIntToLong</a>
121     * <td ><a href="Ops.IntAndIntToDouble.html">Ops.IntAndIntToDouble</a>
122     * <td ><a href="Ops.IntAndIntToObject.html">Ops.IntAndIntToObject</a>
123     * <td >
124     * <tr>
125     * <td >
126     * <td >
127 jsr166 1.6 * <td >{@code long}
128 dl 1.1 * <td ><a href="Ops.IntAndLongToInt.html">Ops.IntAndLongToInt</a>
129     * <td ><a href="Ops.IntAndLongToLong.html">Ops.IntAndLongToLong</a>
130     * <td ><a href="Ops.IntAndLongToDouble.html">Ops.IntAndLongToDouble</a>
131     * <td ><a href="Ops.IntAndLongToObject.html">Ops.IntAndLongToObject</a>
132     * <td >
133     * <tr>
134     * <td >
135     * <td >
136 jsr166 1.6 * <td >{@code double}
137 jsr166 1.2 * <td ><a href="Ops.IntAndDoubleToInt.html">Ops.IntAndDoubleToInt</a>
138     * <td ><a href="Ops.IntAndDoubleToLong.html">Ops.IntAndDoubleToLong</a>
139     * <td ><a href="Ops.IntAndDoubleToDouble.html">Ops.IntAndDoubleToDouble</a>
140     * <td ><a href="Ops.IntAndDoubleToObject.html">Ops.IntAndDoubleToObject</a>
141 dl 1.1 * <td >
142     * <tr>
143     * <td >
144     * <td >
145     * <td >Object
146     * <td ><a href="Ops.IntAndObjectToInt.html">Ops.IntAndObjectToInt</a>
147     * <td ><a href="Ops.IntAndObjectToLong.html">Ops.IntAndObjectToLong</a>
148     * <td ><a href="Ops.IntAndObjectToDouble.html">Ops.IntAndObjectToDouble</a>
149     * <td ><a href="Ops.IntAndObjectToObject.html">Ops.IntAndObjectToObject</a>
150     * <td >
151     * <tr>
152     * <td >
153     * <td >
154     * <td >
155     * <td >
156     * <td >
157     * <td >
158     * <td >
159     * <td >
160     * <tr>
161     * <td >
162 jsr166 1.6 * <td >{@code long}
163 dl 1.1 * <td ><em>&lt;none&gt;</em>
164     * <td ><a href="Ops.LongToInt.html">Ops.LongToInt</a>
165     * <td ><a href="Ops.LongOp.html">Ops.LongOp</a>
166     * <td ><a href="Ops.LongToDouble.html">Ops.LongToDouble</a>
167     * <td ><a href="Ops.LongToObject.html">Ops.LongToObject</a>
168     * <td >
169     * <tr>
170     * <td >
171     * <td >
172 jsr166 1.6 * <td >{@code int}
173 dl 1.1 * <td ><a href="Ops.LongAndIntToInt.html">Ops.LongAndIntToInt</a>
174     * <td ><a href="Ops.LongAndIntToLong.html">Ops.LongAndIntToLong</a>
175     * <td ><a href="Ops.LongAndIntToDouble.html">Ops.LongAndIntToDouble</a>
176     * <td ><a href="Ops.LongAndIntToObject.html">Ops.LongAndIntToObject</a>
177     * <td >
178     * <tr>
179     * <td >
180     * <td >
181 jsr166 1.6 * <td >{@code long}
182 jsr166 1.2 * <td ><a href="Ops.LongAndLongToInt.html">Ops.LongAndLongToInt</a>
183 dl 1.1 * <td ><a href="Ops.BinaryLongOp.html">Ops.BinaryLongOp</a>
184 jsr166 1.2 * <td ><a href="Ops.LongAndLongToDouble.html">Ops.LongAndLongToDouble</a>
185     * <td ><a href="Ops.LongAndLongToObject.html">Ops.LongAndLongToObject</a>
186 dl 1.1 * <td >
187     * <tr>
188     * <td >
189     * <td >
190 jsr166 1.6 * <td >{@code double}
191 dl 1.1 * <td ><a href="Ops.LongAndDoubleToInt.html">Ops.LongAndDoubleToInt</a>
192     * <td ><a href="Ops.LongAndDoubleToLong.html">Ops.LongAndDoubleToLong</a>
193     * <td ><a href="Ops.LongAndDoubleToDouble.html">Ops.LongAndDoubleToDouble</a>
194     * <td ><a href="Ops.LongAndDoubleToObject.html">Ops.LongAndDoubleToObject</a>
195     * <td >
196     * <tr>
197     * <td >
198     * <td >
199     * <td >Object
200     * <td ><a href="Ops.LongAndObjectToInt.html">Ops.LongAndObjectToInt</a>
201     * <td ><a href="Ops.LongAndObjectToLong.html">Ops.LongAndObjectToLong</a>
202     * <td ><a href="Ops.LongAndObjectToDouble.html">Ops.LongAndObjectToDouble</a>
203     * <td ><a href="Ops.LongAndObjectToObject.html">Ops.LongAndObjectToObject</a>
204     * <td >
205     * <tr>
206     * <td >
207     * <td >
208     * <td >
209     * <td >
210     * <td >
211     * <td >
212     * <td >
213     * <td >
214     * <tr>
215     * <td >
216 jsr166 1.6 * <td >{@code double}
217 dl 1.1 * <td ><em>&lt;none&gt;</em>
218     * <td ><a href="Ops.DoubleToInt.html">Ops.DoubleToInt</a>
219     * <td ><a href="Ops.DoubleToLong.html">Ops.DoubleToLong</a>
220     * <td ><a href="Ops.DoubleOp.html">Ops.DoubleOp</a>
221     * <td ><a href="Ops.DoubleToObject.html">Ops.DoubleToObject</a>
222     * <td >
223     * <tr>
224     * <td >
225     * <td >
226 jsr166 1.6 * <td >{@code int}
227 dl 1.1 * <td ><a href="Ops.DoubleAndIntToInt.html">Ops.DoubleAndIntToInt</a>
228     * <td ><a href="Ops.DoubleAndIntToLong.html">Ops.DoubleAndIntToLong</a>
229     * <td ><a href="Ops.DoubleAndIntToDouble.html">Ops.DoubleAndIntToDouble</a>
230     * <td ><a href="Ops.DoubleAndIntToObject.html">Ops.DoubleAndIntToObject</a>
231     * <td >
232     * <tr>
233     * <td >
234     * <td >
235 jsr166 1.6 * <td >{@code long}
236 dl 1.1 * <td ><a href="Ops.DoubleAndLongToInt.html">Ops.DoubleAndLongToInt</a>
237     * <td ><a href="Ops.DoubleAndLongToLong.html">Ops.DoubleAndLongToLong</a>
238     * <td ><a href="Ops.DoubleAndLongToDouble.html">Ops.DoubleAndLongToDouble</a>
239     * <td ><a href="Ops.DoubleAndLongToObject.html">Ops.DoubleAndLongToObject</a>
240     * <td >
241     * <tr>
242     * <td >
243     * <td >
244 jsr166 1.6 * <td >{@code double}
245 dl 1.1 * <td ><a href="Ops.DoubleAndDoubleToInt.html">Ops.DoubleAndDoubleToInt</a>
246     * <td ><a href="Ops.DoubleAndDoubleToLong.html">Ops.DoubleAndDoubleToLong</a>
247     * <td ><a href="Ops.BinaryDoubleOp.html">Ops.BinaryDoubleOp</a>
248     * <td ><a href="Ops.DoubleAndDoubleToObject.html">Ops.DoubleAndDoubleToObject</a>
249     * <tr>
250     * <td >
251     * <td >
252     * <td >Object
253     * <td ><a href="Ops.DoubleAndObjectToInt.html">Ops.DoubleAndObjectToInt</a>
254     * <td ><a href="Ops.DoubleAndObjectToLong.html">Ops.DoubleAndObjectToLong</a>
255     * <td ><a href="Ops.DoubleAndObjectToDouble.html">Ops.DoubleAndObjectToDouble</a>
256     * <td ><a href="Ops.DoubleAndObjectToObject.html">Ops.DoubleAndObjectToObject</a>
257     * <td >
258     * <tr>
259     * <td >
260     * <td >
261     * <td >
262     * <td >
263     * <td >
264     * <td >
265     * <td >
266     * <td >
267     * <tr>
268     * <td >
269     * <td >Object
270     * <td ><em>&lt;none&gt;</em>
271     * <td ><a href="Ops.ObjectToInt.html">Ops.ObjectToInt</a>
272     * <td ><a href="Ops.ObjectToLong.html">Ops.ObjectToLong</a>
273     * <td ><a href="Ops.ObjectToDouble.html">Ops.ObjectToDouble</a>
274     * <td ><a href="Ops.Op.html">Ops.Op</a>
275     * <td >
276     * <tr>
277     * <td >
278     * <td >
279 jsr166 1.6 * <td >{@code int}
280 dl 1.1 * <td ><a href="Ops.ObjectAndIntToInt.html">Ops.ObjectAndIntToInt</a>
281     * <td ><a href="Ops.ObjectAndIntToLong.html">Ops.ObjectAndIntToLong</a>
282     * <td ><a href="Ops.ObjectAndIntToDouble.html">Ops.ObjectAndIntToDouble</a>
283     * <td ><a href="Ops.ObjectAndIntToObject.html">Ops.ObjectAndIntToObject</a>
284     * <td >
285     * <tr>
286     * <td >
287     * <td >
288 jsr166 1.6 * <td >{@code long}
289 dl 1.1 * <td ><a href="Ops.ObjectAndLongToInt.html">Ops.ObjectAndLongToInt</a>
290     * <td ><a href="Ops.ObjectAndLongToLong.html">Ops.ObjectAndLongToLong</a>
291     * <td ><a href="Ops.ObjectAndLongToDouble.html">Ops.ObjectAndLongToDouble</a>
292     * <td ><a href="Ops.ObjectAndLongToObject.html">Ops.ObjectAndLongToObject</a>
293     * <td >
294     * <tr>
295     * <td >
296     * <td >
297 jsr166 1.6 * <td >{@code double}
298 dl 1.1 * <td ><a href="Ops.ObjectAndDoubleToInt.html">Ops.ObjectAndDoubleToInt</a>
299     * <td ><a href="Ops.ObjectAndDoubleToLong.html">Ops.ObjectAndDoubleToLong</a>
300     * <td ><a href="Ops.ObjectAndDoubleToDouble.html">Ops.ObjectAndDoubleToDouble</a>
301     * <td ><a href="Ops.ObjectAndDoubleToObject.html">Ops.ObjectAndDoubleToObject</a>
302     * <td >
303     * <tr>
304     * <td >
305     * <td >
306     * <td >Object
307     * <td ><a href="Ops.ObjectAndObjectToInt.html">Ops.ObjectAndObjectToInt</a>
308     * <td ><a href="Ops.ObjectAndObjectToLong.html">Ops.ObjectAndObjectToLong</a>
309     * <td ><a href="Ops.ObjectAndObjectToDouble.html">Ops.ObjectAndObjectToDouble</a>
310     * <td ><a href="Ops.BinaryOp.html">Ops.BinaryOp</a>
311     * <td >
312     * <tr>
313     * <td >
314     * <td >
315     * <td >
316     * <td >
317     * <td >
318     * <td >
319     * <td >
320     * <td > </table>
321     *
322     * <p>In addition to stated signatures, implementations of these
323     * interfaces must work safely in parallel. In general, this means
324     * methods should operate only on their arguments, and should not rely
325     * on ThreadLocals, unsafely published globals, or other unsafe
326     * constructions. Additionally, they should not block waiting for
327     * synchronization.
328     *
329 jsr166 1.6 * <p>This class is normally best used via {@code import static}.
330 dl 1.1 */
331     public class Ops {
332     private Ops() {} // disable construction
333    
334     // Thanks to David Biesack for the above html table
335     // You want to read/edit this with a wide editor panel
336    
337     public static interface Op<A,R> { R op(A a);}
338     public static interface BinaryOp<A,B,R> { R op(A a, B b);}
339     public static interface Predicate<A> { boolean op(A a);}
340     public static interface BinaryPredicate<A,B> { boolean op(A a, B b);}
341     public static interface Procedure<A> { void op(A a);}
342     public static interface Generator<R> { R op();}
343 jsr166 1.7 public static interface Reducer<A> extends BinaryOp<A,A,A> {}
344 dl 1.1
345     public static interface IntOp { int op(int a);}
346     public static interface BinaryIntOp { int op(int a, int b);}
347     public static interface IntPredicate { boolean op(int a);}
348     public static interface IntProcedure { void op(int a);}
349     public static interface IntGenerator { int op();}
350     public static interface BinaryIntPredicate { boolean op(int a, int b);}
351 jsr166 1.4 public static interface IntReducer extends BinaryIntOp {}
352 dl 1.1 public static interface IntComparator { int compare(int a, int b);}
353    
354     public static interface LongOp { long op(long a);}
355     public static interface BinaryLongOp { long op(long a, long b);}
356     public static interface LongPredicate { boolean op(long a);}
357     public static interface BinaryLongPredicate { boolean op(long a, long b);}
358     public static interface LongProcedure { void op(long a);}
359     public static interface LongGenerator { long op();}
360 jsr166 1.4 public static interface LongReducer extends BinaryLongOp {}
361 dl 1.1 public static interface LongComparator { int compare(long a, long b);}
362    
363     public static interface DoubleOp { double op(double a);}
364     public static interface BinaryDoubleOp { double op(double a, double b);}
365     public static interface DoublePredicate { boolean op(double a);}
366     public static interface BinaryDoublePredicate { boolean op(double a, double b);}
367     public static interface DoubleProcedure { void op(double a);}
368     public static interface DoubleGenerator { double op();}
369 jsr166 1.4 public static interface DoubleReducer extends BinaryDoubleOp {}
370 dl 1.1 public static interface DoubleComparator { int compare(double a, double b);}
371    
372     public static interface Action { void op();}
373    
374     // mixed mode ops
375     public static interface IntToLong { long op(int a);}
376     public static interface IntToDouble { double op(int a);}
377     public static interface IntToObject<R> { R op(int a);}
378     public static interface LongToInt { int op(long a);}
379     public static interface LongToDouble { double op(long a);}
380     public static interface LongToObject<R> { R op(long a);}
381     public static interface DoubleToInt { int op(double a);}
382     public static interface DoubleToLong { long op(double a);}
383     public static interface DoubleToObject<R> { R op(double a);}
384     public static interface ObjectToInt<A> { int op(A a);}
385     public static interface ObjectToLong<A> { long op(A a);}
386     public static interface ObjectToDouble<A> { double op(A a);}
387    
388     public static interface IntAndIntProcedure { void op(int a, int b);}
389     public static interface IntAndIntToLong { long op(int a, int b);}
390     public static interface IntAndIntToDouble { double op(int a, int b);}
391     public static interface IntAndIntToObject<R> { R op(int a, int b);}
392     public static interface IntAndLongProcedure { void op(int a, long b);}
393     public static interface IntAndLongPredicate { boolean op(int a, long b);}
394     public static interface IntAndLongToInt { int op(int a, long b);}
395     public static interface IntAndLongToLong { long op(int a, long b);}
396     public static interface IntAndLongToDouble { double op(int a, long b);}
397     public static interface IntAndLongToObject<R> { R op(int a, long b);}
398     public static interface IntAndDoubleProcedure { void op(int a, double b);}
399     public static interface IntAndDoublePredicate { boolean op(int a, double b);}
400     public static interface IntAndDoubleToInt { int op(int a, double b);}
401     public static interface IntAndDoubleToLong { long op(int a, double b);}
402     public static interface IntAndDoubleToDouble { double op(int a, double b);}
403     public static interface IntAndDoubleToObject<R> { R op(int a, double b);}
404     public static interface IntAndObjectProcedure<A> { void op(int a, A b);}
405     public static interface IntAndObjectPredicate<A> { boolean op(int a, A b);}
406     public static interface IntAndObjectToInt<A> { int op(int a, A b);}
407     public static interface IntAndObjectToLong<A> { long op(int a, A b);}
408     public static interface IntAndObjectToDouble<A> { double op(int a, A b);}
409     public static interface IntAndObjectToObject<A,R> { R op(int a, A b);}
410     public static interface LongAndIntProcedure { void op(long a, int b);}
411     public static interface LongAndIntPredicate { boolean op(long a, int b);}
412     public static interface LongAndIntToInt { int op(long a, int b);}
413     public static interface LongAndIntToLong { long op(long a, int b);}
414     public static interface LongAndIntToDouble { double op(long a, int b);}
415     public static interface LongAndIntToObject<R> { R op(long a, int b);}
416     public static interface LongAndLongProcedure { void op(long a, long b);}
417     public static interface LongAndLongToInt { int op(long a, long b);}
418     public static interface LongAndLongToDouble { double op(long a, long b);}
419     public static interface LongAndLongToObject<R> { R op(long a, long b);}
420     public static interface LongAndDoubleProcedure { void op(long a, double b);}
421     public static interface LongAndDoublePredicate { boolean op(long a, double b);}
422     public static interface LongAndDoubleToInt { int op(long a, double b);}
423     public static interface LongAndDoubleToLong { long op(long a, double b);}
424     public static interface LongAndDoubleToDouble { double op(long a, double b);}
425     public static interface LongAndDoubleToObject<R> { R op(long a, double b);}
426     public static interface LongAndObjectProcedure<A> { void op(long a, A b);}
427     public static interface LongAndObjectPredicate<A> { boolean op(long a, A b);}
428     public static interface LongAndObjectToInt<A> { int op(long a, A b);}
429     public static interface LongAndObjectToLong<A> { long op(long a, A b);}
430     public static interface LongAndObjectToDouble<A> { double op(long a, A b);}
431     public static interface LongAndObjectToObject<A,R> { R op(long a, A b);}
432     public static interface DoubleAndIntProcedure { void op(double a, int b);}
433     public static interface DoubleAndIntPredicate { boolean op(double a, int b);}
434     public static interface DoubleAndIntToInt { int op(double a, int b);}
435     public static interface DoubleAndIntToLong { long op(double a, int b);}
436     public static interface DoubleAndIntToDouble { double op(double a, int b);}
437     public static interface DoubleAndIntToObject<R> { R op(double a, int b);}
438     public static interface DoubleAndLongProcedure { void op(double a, long b);}
439     public static interface DoubleAndLongPredicate { boolean op(double a, long b);}
440     public static interface DoubleAndLongToInt { int op(double a, long b);}
441     public static interface DoubleAndLongToLong { long op(double a, long b);}
442     public static interface DoubleAndLongToDouble { double op(double a, long b);}
443     public static interface DoubleAndLongToObject<R> { R op(double a, long b);}
444     public static interface DoubleAndDoubleProcedure { void op(double a, double b);}
445     public static interface DoubleAndDoubleToInt { int op(double a, double b);}
446     public static interface DoubleAndDoubleToLong { long op(double a, double b);}
447     public static interface DoubleAndDoubleToObject<R> { R op(double a, double b);}
448     public static interface DoubleAndObjectProcedure<A> { void op(double a, A b);}
449     public static interface DoubleAndObjectPredicate<A> { boolean op(double a, A b);}
450     public static interface DoubleAndObjectToInt<A> { int op(double a, A b);}
451     public static interface DoubleAndObjectToLong<A> { long op(double a, A b);}
452     public static interface DoubleAndObjectToDouble<A> { double op(double a, A b);}
453     public static interface DoubleAndObjectToObject<A,R> { R op(double a, A b);}
454     public static interface ObjectAndIntProcedure<A> { void op(A a, int b);}
455     public static interface ObjectAndIntPredicate<A> { boolean op(A a, int b);}
456     public static interface ObjectAndIntToInt<A> { int op(A a, int b);}
457     public static interface ObjectAndIntToLong<A> { long op(A a, int b);}
458     public static interface ObjectAndIntToDouble<A> { double op(A a, int b);}
459     public static interface ObjectAndIntToObject<A,R> { R op(A a, int b);}
460     public static interface ObjectAndLongProcedure<A> { void op(A a, long b);}
461     public static interface ObjectAndLongPredicate<A> { boolean op(A a, long b);}
462     public static interface ObjectAndLongToInt<A> { int op(A a, long b);}
463     public static interface ObjectAndLongToLong<A> { long op(A a, long b);}
464     public static interface ObjectAndLongToDouble<A> { double op(A a, long b);}
465     public static interface ObjectAndLongToObject<A,R> { R op(A a, long b);}
466     public static interface ObjectAndDoubleProcedure<A> { void op(A a, double b);}
467     public static interface ObjectAndDoublePredicate<A> { boolean op(A a, double b);}
468     public static interface ObjectAndDoubleToInt<A> { int op(A a, double b);}
469     public static interface ObjectAndDoubleToLong<A> { long op(A a, double b);}
470     public static interface ObjectAndDoubleToDouble<A> { double op(A a, double b);}
471     public static interface ObjectAndDoubleToObject<A,R> { R op(A a, double b);}
472     public static interface ObjectAndObjectProcedure<A,B>{ void op(A a, B b);}
473     public static interface ObjectAndObjectToInt<A,B> { int op(A a, B b);}
474     public static interface ObjectAndObjectToLong<A,B> { long op(A a, B b);}
475     public static interface ObjectAndObjectToDouble<A,B> { double op(A a, B b);}
476     }