Scala Standard Library 2.12.18 - scala.Byte (original) (raw)

abstract final class Byte extends AnyVal

 

Ordering

1. Alphabetic
2. By Inheritance

Implicitly

1. by byte2Byte

2. by byteWrapper

3. by byte2double

4. by byte2float

5. by byte2long

6. by byte2int

7. by byte2short

8. by any2stringadd

9. by StringFormat

10. by Ensuring

11. by ArrowAssoc

12. Hide All

13. Show All

Abstract Value Members

1.  abstract def !=(x: Double): Boolean
2.  abstract def !=(x: Float): Boolean
3.  abstract def !=(x: Long): Boolean
4.  abstract def !=(x: Int): Boolean
5.  abstract def !=(x: Char): Boolean
6.  abstract def !=(x: Short): Boolean
7.  abstract def !=(x: Byte): Boolean
8.  abstract def %(x: Double): Double
9.  abstract def %(x: Float): Float
10.  abstract def %(x: Long): Long
11.  abstract def %(x: Int): Int
12.  abstract def %(x: Char): Int
13.  abstract def %(x: Short): Int
14.  abstract def %(x: Byte): Int
15.  abstract def &(x: Long): Long
16.  abstract def &(x: Int): Int
17.  abstract def &(x: Char): Int
18.  abstract def &(x: Short): Int
19.  abstract def &(x: Byte): Int
20.  abstract def *(x: Double): Double
21.  abstract def *(x: Float): Float
22.  abstract def *(x: Long): Long
23.  abstract def *(x: Int): Int
24.  abstract def *(x: Char): Int
25.  abstract def *(x: Short): Int
26.  abstract def *(x: Byte): Int
27.  abstract def +(x: Double): Double
28.  abstract def +(x: Float): Float
29.  abstract def +(x: Long): Long
30.  abstract def +(x: Int): Int
31.  abstract def +(x: Char): Int
32.  abstract def +(x: Short): Int
33.  abstract def +(x: Byte): Int
34.  abstract def +(x: String): String
35.  abstract def -(x: Double): Double
36.  abstract def -(x: Float): Float
37.  abstract def -(x: Long): Long
38.  abstract def -(x: Int): Int
39.  abstract def -(x: Char): Int
40.  abstract def -(x: Short): Int
41.  abstract def -(x: Byte): Int
42.  abstract def /(x: Double): Double
43.  abstract def /(x: Float): Float
44.  abstract def /(x: Long): Long
45.  abstract def /(x: Int): Int
46.  abstract def /(x: Char): Int
47.  abstract def /(x: Short): Int
48.  abstract def /(x: Byte): Int
49.  abstract def <(x: Double): Boolean
50.  abstract def <(x: Float): Boolean
51.  abstract def <(x: Long): Boolean
52.  abstract def <(x: Int): Boolean
53.  abstract def <(x: Char): Boolean
54.  abstract def <(x: Short): Boolean
55.  abstract def <(x: Byte): Boolean
56.  abstract def <<(x: Int): Int
57.  abstract def <=(x: Double): Boolean
58.  abstract def <=(x: Float): Boolean
59.  abstract def <=(x: Long): Boolean
60.  abstract def <=(x: Int): Boolean
61.  abstract def <=(x: Char): Boolean
62.  abstract def <=(x: Short): Boolean
63.  abstract def <=(x: Byte): Boolean
64.  abstract def ==(x: Double): Boolean
65.  abstract def ==(x: Float): Boolean
66.  abstract def ==(x: Long): Boolean
67.  abstract def ==(x: Int): Boolean
68.  abstract def ==(x: Char): Boolean
69.  abstract def ==(x: Short): Boolean
70.  abstract def ==(x: Byte): Boolean
71.  abstract def >(x: Double): Boolean
72.  abstract def >(x: Float): Boolean
73.  abstract def >(x: Long): Boolean
74.  abstract def >(x: Int): Boolean
75.  abstract def >(x: Char): Boolean
76.  abstract def >(x: Short): Boolean
77.  abstract def >(x: Byte): Boolean
78.  abstract def >=(x: Double): Boolean
79.  abstract def >=(x: Float): Boolean
80.  abstract def >=(x: Long): Boolean
81.  abstract def >=(x: Int): Boolean
82.  abstract def >=(x: Char): Boolean
83.  abstract def >=(x: Short): Boolean
84.  abstract def >=(x: Byte): Boolean
85.  abstract def >>(x: Int): Int
86.  abstract def >>>(x: Int): Int
87.  abstract def ^(x: Long): Long
88.  abstract def ^(x: Int): Int
89.  abstract def ^(x: Char): Int
90.  abstract def ^(x: Short): Int
91.  abstract def ^(x: Byte): Int
92.  abstract def toByte: Byte
93.  abstract def toChar: Char
94.  abstract def toDouble: Double
95.  abstract def toFloat: Float
96.  abstract def toInt: Int
97.  abstract def toLong: Long
98.  abstract def toShort: Short
99.  abstract def unary_+: Int
100.  abstract def unary_-: Int
101.  abstract def unary_~: Int
102.  abstract def |(x: Long): Long
103.  abstract def |(x: Int): Int
104.  abstract def |(x: Char): Int
105.  abstract def |(x: Short): Int
106.  abstract def |(x: Byte): Int
107.  abstract def <<(x: Long): Int
108.  abstract def >>(x: Long): Int
109.  abstract def >>>(x: Long): Int

Concrete Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def ->[B](y: B): (Byte, B)
4.  final def ==(arg0: Any): Boolean
5.  def abs: Byte
6.  final def asInstanceOf[T0]: T0
7.  def compare(y: Byte): Int
8.  def compareTo(arg0: java.lang.Byte): Int
9.  def compareTo(that: Byte): Int
10.  def ensuring(cond: (Byte) ⇒ Boolean, msg: ⇒ Any): Byte
11.  def ensuring(cond: (Byte) ⇒ Boolean): Byte
12.  def ensuring(cond: Boolean, msg: ⇒ Any): Byte
13.  def ensuring(cond: Boolean): Byte
14.  def equals(arg0: Any): Boolean
15.  def getClass(): Class[Byte]
16.  def hashCode(): Int
17.  final def isInstanceOf[T0]: Boolean
18.  def isValidByte: Boolean
19.  def isValidChar: Boolean
20.  def isValidInt: Boolean
21.  def isValidShort: Boolean
22.  def max(that: Byte): Byte
23.  def min(that: Byte): Byte
24.  val self: Byte
25.  def signum: Int
26.  def toString(): String
27.  def underlying(): AnyRef
28.  def →[B](y: B): (Byte, B)

Shadowed Implicit Value Members

1.  def !=(x: Double): Boolean
2.  def !=(x: Float): Boolean
3.  def !=(x: Long): Boolean
4.  def !=(x: Int): Boolean
5.  def !=(x: Char): Boolean
6.  def !=(x: Short): Boolean
7.  def !=(x: Byte): Boolean
8.  def !=(x: Double): Boolean
9.  def !=(x: Float): Boolean
10.  def !=(x: Long): Boolean
11.  def !=(x: Int): Boolean
12.  def !=(x: Char): Boolean
13.  def !=(x: Short): Boolean
14.  def !=(x: Byte): Boolean
15.  def !=(x: Double): Boolean
16.  def !=(x: Float): Boolean
17.  def !=(x: Long): Boolean
18.  def !=(x: Int): Boolean
19.  def !=(x: Char): Boolean
20.  def !=(x: Short): Boolean
21.  def !=(x: Byte): Boolean
22.  def !=(x: Double): Boolean
23.  def !=(x: Float): Boolean
24.  def !=(x: Long): Boolean
25.  def !=(x: Int): Boolean
26.  def !=(x: Char): Boolean
27.  def !=(x: Short): Boolean
28.  def !=(x: Byte): Boolean
29.  def !=(x: Double): Boolean
30.  def !=(x: Float): Boolean
31.  def !=(x: Long): Boolean
32.  def !=(x: Int): Boolean
33.  def !=(x: Char): Boolean
34.  def !=(x: Short): Boolean
35.  def !=(x: Byte): Boolean
36.  def %(x: Double): Double
37.  def %(x: Float): Double
38.  def %(x: Long): Double
39.  def %(x: Int): Double
40.  def %(x: Char): Double
41.  def %(x: Short): Double
42.  def %(x: Byte): Double
43.  def %(x: Double): Double
44.  def %(x: Float): Float
45.  def %(x: Long): Float
46.  def %(x: Int): Float
47.  def %(x: Char): Float
48.  def %(x: Short): Float
49.  def %(x: Byte): Float
50.  def %(x: Double): Double
51.  def %(x: Float): Float
52.  def %(x: Long): Long
53.  def %(x: Int): Long
54.  def %(x: Char): Long
55.  def %(x: Short): Long
56.  def %(x: Byte): Long
57.  def %(x: Double): Double
58.  def %(x: Float): Float
59.  def %(x: Long): Long
60.  def %(x: Int): Int
61.  def %(x: Char): Int
62.  def %(x: Short): Int
63.  def %(x: Byte): Int
64.  def %(x: Double): Double
65.  def %(x: Float): Float
66.  def %(x: Long): Long
67.  def %(x: Int): Int
68.  def %(x: Char): Int
69.  def %(x: Short): Int
70.  def %(x: Byte): Int
71.  def &(x: Long): Long
72.  def &(x: Int): Long
73.  def &(x: Char): Long
74.  def &(x: Short): Long
75.  def &(x: Byte): Long
76.  def &(x: Long): Long
77.  def &(x: Int): Int
78.  def &(x: Char): Int
79.  def &(x: Short): Int
80.  def &(x: Byte): Int
81.  def &(x: Long): Long
82.  def &(x: Int): Int
83.  def &(x: Char): Int
84.  def &(x: Short): Int
85.  def &(x: Byte): Int
86.  def *(x: Double): Double
87.  def *(x: Float): Double
88.  def *(x: Long): Double
89.  def *(x: Int): Double
90.  def *(x: Char): Double
91.  def *(x: Short): Double
92.  def *(x: Byte): Double
93.  def *(x: Double): Double
94.  def *(x: Float): Float
95.  def *(x: Long): Float
96.  def *(x: Int): Float
97.  def *(x: Char): Float
98.  def *(x: Short): Float
99.  def *(x: Byte): Float
100.  def *(x: Double): Double
101.  def *(x: Float): Float
102.  def *(x: Long): Long
103.  def *(x: Int): Long
104.  def *(x: Char): Long
105.  def *(x: Short): Long
106.  def *(x: Byte): Long
107.  def *(x: Double): Double
108.  def *(x: Float): Float
109.  def *(x: Long): Long
110.  def *(x: Int): Int
111.  def *(x: Char): Int
112.  def *(x: Short): Int
113.  def *(x: Byte): Int
114.  def *(x: Double): Double
115.  def *(x: Float): Float
116.  def *(x: Long): Long
117.  def *(x: Int): Int
118.  def *(x: Char): Int
119.  def *(x: Short): Int
120.  def *(x: Byte): Int
121.  def +(x: Double): Double
122.  def +(x: Float): Double
123.  def +(x: Long): Double
124.  def +(x: Int): Double
125.  def +(x: Char): Double
126.  def +(x: Short): Double
127.  def +(x: Byte): Double
128.  def +(x: String): String
129.  def +(x: Double): Double
130.  def +(x: Float): Float
131.  def +(x: Long): Float
132.  def +(x: Int): Float
133.  def +(x: Char): Float
134.  def +(x: Short): Float
135.  def +(x: Byte): Float
136.  def +(x: String): String
137.  def +(x: Double): Double
138.  def +(x: Float): Float
139.  def +(x: Long): Long
140.  def +(x: Int): Long
141.  def +(x: Char): Long
142.  def +(x: Short): Long
143.  def +(x: Byte): Long
144.  def +(x: String): String
145.  def +(x: Double): Double
146.  def +(x: Float): Float
147.  def +(x: Long): Long
148.  def +(x: Int): Int
149.  def +(x: Char): Int
150.  def +(x: Short): Int
151.  def +(x: Byte): Int
152.  def +(x: String): String
153.  def +(x: Double): Double
154.  def +(x: Float): Float
155.  def +(x: Long): Long
156.  def +(x: Int): Int
157.  def +(x: Char): Int
158.  def +(x: Short): Int
159.  def +(x: Byte): Int
160.  def +(x: String): String
161.  def +(other: String): String
162.  def -(x: Double): Double
163.  def -(x: Float): Double
164.  def -(x: Long): Double
165.  def -(x: Int): Double
166.  def -(x: Char): Double
167.  def -(x: Short): Double
168.  def -(x: Byte): Double
169.  def -(x: Double): Double
170.  def -(x: Float): Float
171.  def -(x: Long): Float
172.  def -(x: Int): Float
173.  def -(x: Char): Float
174.  def -(x: Short): Float
175.  def -(x: Byte): Float
176.  def -(x: Double): Double
177.  def -(x: Float): Float
178.  def -(x: Long): Long
179.  def -(x: Int): Long
180.  def -(x: Char): Long
181.  def -(x: Short): Long
182.  def -(x: Byte): Long
183.  def -(x: Double): Double
184.  def -(x: Float): Float
185.  def -(x: Long): Long
186.  def -(x: Int): Int
187.  def -(x: Char): Int
188.  def -(x: Short): Int
189.  def -(x: Byte): Int
190.  def -(x: Double): Double
191.  def -(x: Float): Float
192.  def -(x: Long): Long
193.  def -(x: Int): Int
194.  def -(x: Char): Int
195.  def -(x: Short): Int
196.  def -(x: Byte): Int
197.  def /(x: Double): Double
198.  def /(x: Float): Double
199.  def /(x: Long): Double
200.  def /(x: Int): Double
201.  def /(x: Char): Double
202.  def /(x: Short): Double
203.  def /(x: Byte): Double
204.  def /(x: Double): Double
205.  def /(x: Float): Float
206.  def /(x: Long): Float
207.  def /(x: Int): Float
208.  def /(x: Char): Float
209.  def /(x: Short): Float
210.  def /(x: Byte): Float
211.  def /(x: Double): Double
212.  def /(x: Float): Float
213.  def /(x: Long): Long
214.  def /(x: Int): Long
215.  def /(x: Char): Long
216.  def /(x: Short): Long
217.  def /(x: Byte): Long
218.  def /(x: Double): Double
219.  def /(x: Float): Float
220.  def /(x: Long): Long
221.  def /(x: Int): Int
222.  def /(x: Char): Int
223.  def /(x: Short): Int
224.  def /(x: Byte): Int
225.  def /(x: Double): Double
226.  def /(x: Float): Float
227.  def /(x: Long): Long
228.  def /(x: Int): Int
229.  def /(x: Char): Int
230.  def /(x: Short): Int
231.  def /(x: Byte): Int
232.  def <(that: Byte): Boolean
233.  def <(x: Double): Boolean
234.  def <(x: Float): Boolean
235.  def <(x: Long): Boolean
236.  def <(x: Int): Boolean
237.  def <(x: Char): Boolean
238.  def <(x: Short): Boolean
239.  def <(x: Byte): Boolean
240.  def <(x: Double): Boolean
241.  def <(x: Float): Boolean
242.  def <(x: Long): Boolean
243.  def <(x: Int): Boolean
244.  def <(x: Char): Boolean
245.  def <(x: Short): Boolean
246.  def <(x: Byte): Boolean
247.  def <(x: Double): Boolean
248.  def <(x: Float): Boolean
249.  def <(x: Long): Boolean
250.  def <(x: Int): Boolean
251.  def <(x: Char): Boolean
252.  def <(x: Short): Boolean
253.  def <(x: Byte): Boolean
254.  def <(x: Double): Boolean
255.  def <(x: Float): Boolean
256.  def <(x: Long): Boolean
257.  def <(x: Int): Boolean
258.  def <(x: Char): Boolean
259.  def <(x: Short): Boolean
260.  def <(x: Byte): Boolean
261.  def <(x: Double): Boolean
262.  def <(x: Float): Boolean
263.  def <(x: Long): Boolean
264.  def <(x: Int): Boolean
265.  def <(x: Char): Boolean
266.  def <(x: Short): Boolean
267.  def <(x: Byte): Boolean
268.  def <<(x: Long): Long
269.  def <<(x: Int): Long
270.  def <<(x: Int): Int
271.  def <<(x: Int): Int
272.  def <=(that: Byte): Boolean
273.  def <=(x: Double): Boolean
274.  def <=(x: Float): Boolean
275.  def <=(x: Long): Boolean
276.  def <=(x: Int): Boolean
277.  def <=(x: Char): Boolean
278.  def <=(x: Short): Boolean
279.  def <=(x: Byte): Boolean
280.  def <=(x: Double): Boolean
281.  def <=(x: Float): Boolean
282.  def <=(x: Long): Boolean
283.  def <=(x: Int): Boolean
284.  def <=(x: Char): Boolean
285.  def <=(x: Short): Boolean
286.  def <=(x: Byte): Boolean
287.  def <=(x: Double): Boolean
288.  def <=(x: Float): Boolean
289.  def <=(x: Long): Boolean
290.  def <=(x: Int): Boolean
291.  def <=(x: Char): Boolean
292.  def <=(x: Short): Boolean
293.  def <=(x: Byte): Boolean
294.  def <=(x: Double): Boolean
295.  def <=(x: Float): Boolean
296.  def <=(x: Long): Boolean
297.  def <=(x: Int): Boolean
298.  def <=(x: Char): Boolean
299.  def <=(x: Short): Boolean
300.  def <=(x: Byte): Boolean
301.  def <=(x: Double): Boolean
302.  def <=(x: Float): Boolean
303.  def <=(x: Long): Boolean
304.  def <=(x: Int): Boolean
305.  def <=(x: Char): Boolean
306.  def <=(x: Short): Boolean
307.  def <=(x: Byte): Boolean
308.  def ==(x: Double): Boolean
309.  def ==(x: Float): Boolean
310.  def ==(x: Long): Boolean
311.  def ==(x: Int): Boolean
312.  def ==(x: Char): Boolean
313.  def ==(x: Short): Boolean
314.  def ==(x: Byte): Boolean
315.  def ==(x: Double): Boolean
316.  def ==(x: Float): Boolean
317.  def ==(x: Long): Boolean
318.  def ==(x: Int): Boolean
319.  def ==(x: Char): Boolean
320.  def ==(x: Short): Boolean
321.  def ==(x: Byte): Boolean
322.  def ==(x: Double): Boolean
323.  def ==(x: Float): Boolean
324.  def ==(x: Long): Boolean
325.  def ==(x: Int): Boolean
326.  def ==(x: Char): Boolean
327.  def ==(x: Short): Boolean
328.  def ==(x: Byte): Boolean
329.  def ==(x: Double): Boolean
330.  def ==(x: Float): Boolean
331.  def ==(x: Long): Boolean
332.  def ==(x: Int): Boolean
333.  def ==(x: Char): Boolean
334.  def ==(x: Short): Boolean
335.  def ==(x: Byte): Boolean
336.  def ==(x: Double): Boolean
337.  def ==(x: Float): Boolean
338.  def ==(x: Long): Boolean
339.  def ==(x: Int): Boolean
340.  def ==(x: Char): Boolean
341.  def ==(x: Short): Boolean
342.  def ==(x: Byte): Boolean
343.  def >(that: Byte): Boolean
344.  def >(x: Double): Boolean
345.  def >(x: Float): Boolean
346.  def >(x: Long): Boolean
347.  def >(x: Int): Boolean
348.  def >(x: Char): Boolean
349.  def >(x: Short): Boolean
350.  def >(x: Byte): Boolean
351.  def >(x: Double): Boolean
352.  def >(x: Float): Boolean
353.  def >(x: Long): Boolean
354.  def >(x: Int): Boolean
355.  def >(x: Char): Boolean
356.  def >(x: Short): Boolean
357.  def >(x: Byte): Boolean
358.  def >(x: Double): Boolean
359.  def >(x: Float): Boolean
360.  def >(x: Long): Boolean
361.  def >(x: Int): Boolean
362.  def >(x: Char): Boolean
363.  def >(x: Short): Boolean
364.  def >(x: Byte): Boolean
365.  def >(x: Double): Boolean
366.  def >(x: Float): Boolean
367.  def >(x: Long): Boolean
368.  def >(x: Int): Boolean
369.  def >(x: Char): Boolean
370.  def >(x: Short): Boolean
371.  def >(x: Byte): Boolean
372.  def >(x: Double): Boolean
373.  def >(x: Float): Boolean
374.  def >(x: Long): Boolean
375.  def >(x: Int): Boolean
376.  def >(x: Char): Boolean
377.  def >(x: Short): Boolean
378.  def >(x: Byte): Boolean
379.  def >=(that: Byte): Boolean
380.  def >=(x: Double): Boolean
381.  def >=(x: Float): Boolean
382.  def >=(x: Long): Boolean
383.  def >=(x: Int): Boolean
384.  def >=(x: Char): Boolean
385.  def >=(x: Short): Boolean
386.  def >=(x: Byte): Boolean
387.  def >=(x: Double): Boolean
388.  def >=(x: Float): Boolean
389.  def >=(x: Long): Boolean
390.  def >=(x: Int): Boolean
391.  def >=(x: Char): Boolean
392.  def >=(x: Short): Boolean
393.  def >=(x: Byte): Boolean
394.  def >=(x: Double): Boolean
395.  def >=(x: Float): Boolean
396.  def >=(x: Long): Boolean
397.  def >=(x: Int): Boolean
398.  def >=(x: Char): Boolean
399.  def >=(x: Short): Boolean
400.  def >=(x: Byte): Boolean
401.  def >=(x: Double): Boolean
402.  def >=(x: Float): Boolean
403.  def >=(x: Long): Boolean
404.  def >=(x: Int): Boolean
405.  def >=(x: Char): Boolean
406.  def >=(x: Short): Boolean
407.  def >=(x: Byte): Boolean
408.  def >=(x: Double): Boolean
409.  def >=(x: Float): Boolean
410.  def >=(x: Long): Boolean
411.  def >=(x: Int): Boolean
412.  def >=(x: Char): Boolean
413.  def >=(x: Short): Boolean
414.  def >=(x: Byte): Boolean
415.  def >>(x: Long): Long
416.  def >>(x: Int): Long
417.  def >>(x: Int): Int
418.  def >>(x: Int): Int
419.  def >>>(x: Long): Long
420.  def >>>(x: Int): Long
421.  def >>>(x: Int): Int
422.  def >>>(x: Int): Int
423.  def ^(x: Long): Long
424.  def ^(x: Int): Long
425.  def ^(x: Char): Long
426.  def ^(x: Short): Long
427.  def ^(x: Byte): Long
428.  def ^(x: Long): Long
429.  def ^(x: Int): Int
430.  def ^(x: Char): Int
431.  def ^(x: Short): Int
432.  def ^(x: Byte): Int
433.  def ^(x: Long): Long
434.  def ^(x: Int): Int
435.  def ^(x: Char): Int
436.  def ^(x: Short): Int
437.  def ^(x: Byte): Int
438.  def byteValue(): Byte
439.  def byteValue(): Byte
440.  def doubleValue(): Double
441.  def doubleValue(): Double
442.  def equals(arg0: Any): Boolean
443.  def floatValue(): Float
444.  def floatValue(): Float
445.  def hashCode(): Int
446.  def intValue(): Int
447.  def intValue(): Int
448.  def longValue(): Long
449.  def longValue(): Long
450.  def shortValue(): Short
451.  def shortValue(): Short
452.  def toByte: Byte
453.  def toByte: Byte
454.  def toByte: Byte
455.  def toByte: Byte
456.  def toByte: Byte
457.  def toByte: Byte
458.  def toChar: Char
459.  def toChar: Char
460.  def toChar: Char
461.  def toChar: Char
462.  def toChar: Char
463.  def toChar: Char
464.  def toDouble: Double
465.  def toDouble: Double
466.  def toDouble: Double
467.  def toDouble: Double
468.  def toDouble: Double
469.  def toDouble: Double
470.  def toFloat: Float
471.  def toFloat: Float
472.  def toFloat: Float
473.  def toFloat: Float
474.  def toFloat: Float
475.  def toFloat: Float
476.  def toInt: Int
477.  def toInt: Int
478.  def toInt: Int
479.  def toInt: Int
480.  def toInt: Int
481.  def toInt: Int
482.  def toLong: Long
483.  def toLong: Long
484.  def toLong: Long
485.  def toLong: Long
486.  def toLong: Long
487.  def toLong: Long
488.  def toShort: Short
489.  def toShort: Short
490.  def toShort: Short
491.  def toShort: Short
492.  def toShort: Short
493.  def toShort: Short
494.  def toString(): String
495.  def toString(): String
496.  def unary_+: Double
497.  def unary_+: Float
498.  def unary_+: Long
499.  def unary_+: Int
500.  def unary_+: Int
501.  def unary_-: Double
502.  def unary_-: Float
503.  def unary_-: Long
504.  def unary_-: Int
505.  def unary_-: Int
506.  def unary_~: Long
507.  def unary_~: Int
508.  def unary_~: Int
509.  def |(x: Long): Long
510.  def |(x: Int): Long
511.  def |(x: Char): Long
512.  def |(x: Short): Long
513.  def |(x: Byte): Long
514.  def |(x: Long): Long
515.  def |(x: Int): Int
516.  def |(x: Char): Int
517.  def |(x: Short): Int
518.  def |(x: Byte): Int
519.  def |(x: Long): Long
520.  def |(x: Int): Int
521.  def |(x: Char): Int
522.  def |(x: Short): Int
523.  def |(x: Byte): Int

Inherited from AnyVal

Inherited from Any

Inherited by implicit conversion byte2Byte fromByte to java.lang.Byte

Inherited by implicit conversion byteWrapper fromByte to RichByte

Inherited by implicit conversion byte2double fromByte to Double

Inherited by implicit conversion byte2float fromByte to Float

Inherited by implicit conversion byte2long fromByte to Long

Inherited by implicit conversion byte2int fromByte to Int

Inherited by implicit conversion byte2short fromByte to Short

Inherited by implicit conversion any2stringadd fromByte to any2stringadd[Byte]

Inherited by implicit conversion StringFormat fromByte to StringFormat[Byte]

Inherited by implicit conversion Ensuring fromByte to Ensuring[Byte]

Inherited by implicit conversion ArrowAssoc fromByte to ArrowAssoc[Byte]

Ungrouped