Scala Standard Library 2.13.1 - 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

Visibility

1. Public
2. Protected

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: Double): Double
35.  abstract def -(x: Float): Float
36.  abstract def -(x: Long): Long
37.  abstract def -(x: Int): Int
38.  abstract def -(x: Char): Int
39.  abstract def -(x: Short): Int
40.  abstract def -(x: Byte): Int
41.  abstract def /(x: Double): Double
42.  abstract def /(x: Float): Float
43.  abstract def /(x: Long): Long
44.  abstract def /(x: Int): Int
45.  abstract def /(x: Char): Int
46.  abstract def /(x: Short): Int
47.  abstract def /(x: Byte): Int
48.  abstract def <(x: Double): Boolean
49.  abstract def <(x: Float): Boolean
50.  abstract def <(x: Long): Boolean
51.  abstract def <(x: Int): Boolean
52.  abstract def <(x: Char): Boolean
53.  abstract def <(x: Short): Boolean
54.  abstract def <(x: Byte): Boolean
55.  abstract def <<(x: Int): Int
56.  abstract def <=(x: Double): Boolean
57.  abstract def <=(x: Float): Boolean
58.  abstract def <=(x: Long): Boolean
59.  abstract def <=(x: Int): Boolean
60.  abstract def <=(x: Char): Boolean
61.  abstract def <=(x: Short): Boolean
62.  abstract def <=(x: Byte): Boolean
63.  abstract def ==(x: Double): Boolean
64.  abstract def ==(x: Float): Boolean
65.  abstract def ==(x: Long): Boolean
66.  abstract def ==(x: Int): Boolean
67.  abstract def ==(x: Char): Boolean
68.  abstract def ==(x: Short): Boolean
69.  abstract def ==(x: Byte): Boolean
70.  abstract def >(x: Double): Boolean
71.  abstract def >(x: Float): Boolean
72.  abstract def >(x: Long): Boolean
73.  abstract def >(x: Int): Boolean
74.  abstract def >(x: Char): Boolean
75.  abstract def >(x: Short): Boolean
76.  abstract def >(x: Byte): Boolean
77.  abstract def >=(x: Double): Boolean
78.  abstract def >=(x: Float): Boolean
79.  abstract def >=(x: Long): Boolean
80.  abstract def >=(x: Int): Boolean
81.  abstract def >=(x: Char): Boolean
82.  abstract def >=(x: Short): Boolean
83.  abstract def >=(x: Byte): Boolean
84.  abstract def >>(x: Int): Int
85.  abstract def >>>(x: Int): Int
86.  abstract def ^(x: Long): Long
87.  abstract def ^(x: Int): Int
88.  abstract def ^(x: Char): Int
89.  abstract def ^(x: Short): Int
90.  abstract def ^(x: Byte): Int
91.  abstract def toByte: Byte
92.  abstract def toChar: Char
93.  abstract def toDouble: Double
94.  abstract def toFloat: Float
95.  abstract def toInt: Int
96.  abstract def toLong: Long
97.  abstract def toShort: Short
98.  abstract def unary_+: Int
99.  abstract def unary_-: Int
100.  abstract def unary_~: Int
101.  abstract def |(x: Long): Long
102.  abstract def |(x: Int): Int
103.  abstract def |(x: Char): Int
104.  abstract def |(x: Short): Int
105.  abstract def |(x: Byte): Int
106.  abstract def +(x: String): String
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 byteValue(): Byte
8.  def byteValue: Byte
9.  def compare(y: Byte): Int
10.  def compareTo(arg0: java.lang.Byte): Int
11.  def compareTo(that: Byte): Int
12.  def doubleValue(): Double
13.  def doubleValue: Double
14.  def ensuring(cond: (Byte) => Boolean, msg: => Any): Byte
15.  def ensuring(cond: (Byte) => Boolean): Byte
16.  def ensuring(cond: Boolean, msg: => Any): Byte
17.  def ensuring(cond: Boolean): Byte
18.  def equals(arg0: Any): Boolean
19.  def floatValue(): Float
20.  def floatValue: Float
21.  def formatted(fmtstr: String): String
22.  def getClass(): Class[Byte]
23.  def hashCode(): Int
24.  def intValue(): Int
25.  def intValue: Int
26.  final def isInstanceOf[T0]: Boolean
27.  def isValidByte: Boolean
28.  def isValidChar: Boolean
29.  def isValidInt: Boolean
30.  def isValidShort: Boolean
31.  def isWhole: Boolean
32.  def longValue(): Long
33.  def longValue: Long
34.  def max(that: Byte): Byte
35.  def min(that: Byte): Byte
36.  val self: Byte
37.  def shortValue(): Short
38.  def shortValue: Short
39.  def sign: Byte
40.  def toString(): String

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: Double): Double
129.  def +(x: Float): Float
130.  def +(x: Long): Float
131.  def +(x: Int): Float
132.  def +(x: Char): Float
133.  def +(x: Short): Float
134.  def +(x: Byte): Float
135.  def +(x: Double): Double
136.  def +(x: Float): Float
137.  def +(x: Long): Long
138.  def +(x: Int): Long
139.  def +(x: Char): Long
140.  def +(x: Short): Long
141.  def +(x: Byte): Long
142.  def +(x: Double): Double
143.  def +(x: Float): Float
144.  def +(x: Long): Long
145.  def +(x: Int): Int
146.  def +(x: Char): Int
147.  def +(x: Short): Int
148.  def +(x: Byte): Int
149.  def +(x: Double): Double
150.  def +(x: Float): Float
151.  def +(x: Long): Long
152.  def +(x: Int): Int
153.  def +(x: Char): Int
154.  def +(x: Short): Int
155.  def +(x: Byte): Int
156.  def +(other: String): String
157.  def -(x: Double): Double
158.  def -(x: Float): Double
159.  def -(x: Long): Double
160.  def -(x: Int): Double
161.  def -(x: Char): Double
162.  def -(x: Short): Double
163.  def -(x: Byte): Double
164.  def -(x: Double): Double
165.  def -(x: Float): Float
166.  def -(x: Long): Float
167.  def -(x: Int): Float
168.  def -(x: Char): Float
169.  def -(x: Short): Float
170.  def -(x: Byte): Float
171.  def -(x: Double): Double
172.  def -(x: Float): Float
173.  def -(x: Long): Long
174.  def -(x: Int): Long
175.  def -(x: Char): Long
176.  def -(x: Short): Long
177.  def -(x: Byte): Long
178.  def -(x: Double): Double
179.  def -(x: Float): Float
180.  def -(x: Long): Long
181.  def -(x: Int): Int
182.  def -(x: Char): Int
183.  def -(x: Short): Int
184.  def -(x: Byte): Int
185.  def -(x: Double): Double
186.  def -(x: Float): Float
187.  def -(x: Long): Long
188.  def -(x: Int): Int
189.  def -(x: Char): Int
190.  def -(x: Short): Int
191.  def -(x: Byte): Int
192.  def /(x: Double): Double
193.  def /(x: Float): Double
194.  def /(x: Long): Double
195.  def /(x: Int): Double
196.  def /(x: Char): Double
197.  def /(x: Short): Double
198.  def /(x: Byte): Double
199.  def /(x: Double): Double
200.  def /(x: Float): Float
201.  def /(x: Long): Float
202.  def /(x: Int): Float
203.  def /(x: Char): Float
204.  def /(x: Short): Float
205.  def /(x: Byte): Float
206.  def /(x: Double): Double
207.  def /(x: Float): Float
208.  def /(x: Long): Long
209.  def /(x: Int): Long
210.  def /(x: Char): Long
211.  def /(x: Short): Long
212.  def /(x: Byte): Long
213.  def /(x: Double): Double
214.  def /(x: Float): Float
215.  def /(x: Long): Long
216.  def /(x: Int): Int
217.  def /(x: Char): Int
218.  def /(x: Short): Int
219.  def /(x: Byte): Int
220.  def /(x: Double): Double
221.  def /(x: Float): Float
222.  def /(x: Long): Long
223.  def /(x: Int): Int
224.  def /(x: Char): Int
225.  def /(x: Short): Int
226.  def /(x: Byte): Int
227.  def <(that: Byte): Boolean
228.  def <(x: Double): Boolean
229.  def <(x: Float): Boolean
230.  def <(x: Long): Boolean
231.  def <(x: Int): Boolean
232.  def <(x: Char): Boolean
233.  def <(x: Short): Boolean
234.  def <(x: Byte): Boolean
235.  def <(x: Double): Boolean
236.  def <(x: Float): Boolean
237.  def <(x: Long): Boolean
238.  def <(x: Int): Boolean
239.  def <(x: Char): Boolean
240.  def <(x: Short): Boolean
241.  def <(x: Byte): Boolean
242.  def <(x: Double): Boolean
243.  def <(x: Float): Boolean
244.  def <(x: Long): Boolean
245.  def <(x: Int): Boolean
246.  def <(x: Char): Boolean
247.  def <(x: Short): Boolean
248.  def <(x: Byte): Boolean
249.  def <(x: Double): Boolean
250.  def <(x: Float): Boolean
251.  def <(x: Long): Boolean
252.  def <(x: Int): Boolean
253.  def <(x: Char): Boolean
254.  def <(x: Short): Boolean
255.  def <(x: Byte): Boolean
256.  def <(x: Double): Boolean
257.  def <(x: Float): Boolean
258.  def <(x: Long): Boolean
259.  def <(x: Int): Boolean
260.  def <(x: Char): Boolean
261.  def <(x: Short): Boolean
262.  def <(x: Byte): Boolean
263.  def <<(x: Long): Long
264.  def <<(x: Int): Long
265.  def <<(x: Int): Int
266.  def <<(x: Int): Int
267.  def <=(that: Byte): Boolean
268.  def <=(x: Double): Boolean
269.  def <=(x: Float): Boolean
270.  def <=(x: Long): Boolean
271.  def <=(x: Int): Boolean
272.  def <=(x: Char): Boolean
273.  def <=(x: Short): Boolean
274.  def <=(x: Byte): Boolean
275.  def <=(x: Double): Boolean
276.  def <=(x: Float): Boolean
277.  def <=(x: Long): Boolean
278.  def <=(x: Int): Boolean
279.  def <=(x: Char): Boolean
280.  def <=(x: Short): Boolean
281.  def <=(x: Byte): Boolean
282.  def <=(x: Double): Boolean
283.  def <=(x: Float): Boolean
284.  def <=(x: Long): Boolean
285.  def <=(x: Int): Boolean
286.  def <=(x: Char): Boolean
287.  def <=(x: Short): Boolean
288.  def <=(x: Byte): Boolean
289.  def <=(x: Double): Boolean
290.  def <=(x: Float): Boolean
291.  def <=(x: Long): Boolean
292.  def <=(x: Int): Boolean
293.  def <=(x: Char): Boolean
294.  def <=(x: Short): Boolean
295.  def <=(x: Byte): Boolean
296.  def <=(x: Double): Boolean
297.  def <=(x: Float): Boolean
298.  def <=(x: Long): Boolean
299.  def <=(x: Int): Boolean
300.  def <=(x: Char): Boolean
301.  def <=(x: Short): Boolean
302.  def <=(x: Byte): Boolean
303.  def ==(x: Double): Boolean
304.  def ==(x: Float): Boolean
305.  def ==(x: Long): Boolean
306.  def ==(x: Int): Boolean
307.  def ==(x: Char): Boolean
308.  def ==(x: Short): Boolean
309.  def ==(x: Byte): Boolean
310.  def ==(x: Double): Boolean
311.  def ==(x: Float): Boolean
312.  def ==(x: Long): Boolean
313.  def ==(x: Int): Boolean
314.  def ==(x: Char): Boolean
315.  def ==(x: Short): Boolean
316.  def ==(x: Byte): Boolean
317.  def ==(x: Double): Boolean
318.  def ==(x: Float): Boolean
319.  def ==(x: Long): Boolean
320.  def ==(x: Int): Boolean
321.  def ==(x: Char): Boolean
322.  def ==(x: Short): Boolean
323.  def ==(x: Byte): Boolean
324.  def ==(x: Double): Boolean
325.  def ==(x: Float): Boolean
326.  def ==(x: Long): Boolean
327.  def ==(x: Int): Boolean
328.  def ==(x: Char): Boolean
329.  def ==(x: Short): Boolean
330.  def ==(x: Byte): Boolean
331.  def ==(x: Double): Boolean
332.  def ==(x: Float): Boolean
333.  def ==(x: Long): Boolean
334.  def ==(x: Int): Boolean
335.  def ==(x: Char): Boolean
336.  def ==(x: Short): Boolean
337.  def ==(x: Byte): Boolean
338.  def >(that: Byte): Boolean
339.  def >(x: Double): Boolean
340.  def >(x: Float): Boolean
341.  def >(x: Long): Boolean
342.  def >(x: Int): Boolean
343.  def >(x: Char): Boolean
344.  def >(x: Short): Boolean
345.  def >(x: Byte): Boolean
346.  def >(x: Double): Boolean
347.  def >(x: Float): Boolean
348.  def >(x: Long): Boolean
349.  def >(x: Int): Boolean
350.  def >(x: Char): Boolean
351.  def >(x: Short): Boolean
352.  def >(x: Byte): Boolean
353.  def >(x: Double): Boolean
354.  def >(x: Float): Boolean
355.  def >(x: Long): Boolean
356.  def >(x: Int): Boolean
357.  def >(x: Char): Boolean
358.  def >(x: Short): Boolean
359.  def >(x: Byte): Boolean
360.  def >(x: Double): Boolean
361.  def >(x: Float): Boolean
362.  def >(x: Long): Boolean
363.  def >(x: Int): Boolean
364.  def >(x: Char): Boolean
365.  def >(x: Short): Boolean
366.  def >(x: Byte): Boolean
367.  def >(x: Double): Boolean
368.  def >(x: Float): Boolean
369.  def >(x: Long): Boolean
370.  def >(x: Int): Boolean
371.  def >(x: Char): Boolean
372.  def >(x: Short): Boolean
373.  def >(x: Byte): Boolean
374.  def >=(that: Byte): Boolean
375.  def >=(x: Double): Boolean
376.  def >=(x: Float): Boolean
377.  def >=(x: Long): Boolean
378.  def >=(x: Int): Boolean
379.  def >=(x: Char): Boolean
380.  def >=(x: Short): Boolean
381.  def >=(x: Byte): Boolean
382.  def >=(x: Double): Boolean
383.  def >=(x: Float): Boolean
384.  def >=(x: Long): Boolean
385.  def >=(x: Int): Boolean
386.  def >=(x: Char): Boolean
387.  def >=(x: Short): Boolean
388.  def >=(x: Byte): Boolean
389.  def >=(x: Double): Boolean
390.  def >=(x: Float): Boolean
391.  def >=(x: Long): Boolean
392.  def >=(x: Int): Boolean
393.  def >=(x: Char): Boolean
394.  def >=(x: Short): Boolean
395.  def >=(x: Byte): Boolean
396.  def >=(x: Double): Boolean
397.  def >=(x: Float): Boolean
398.  def >=(x: Long): Boolean
399.  def >=(x: Int): Boolean
400.  def >=(x: Char): Boolean
401.  def >=(x: Short): Boolean
402.  def >=(x: Byte): Boolean
403.  def >=(x: Double): Boolean
404.  def >=(x: Float): Boolean
405.  def >=(x: Long): Boolean
406.  def >=(x: Int): Boolean
407.  def >=(x: Char): Boolean
408.  def >=(x: Short): Boolean
409.  def >=(x: Byte): Boolean
410.  def >>(x: Long): Long
411.  def >>(x: Int): Long
412.  def >>(x: Int): Int
413.  def >>(x: Int): Int
414.  def >>>(x: Long): Long
415.  def >>>(x: Int): Long
416.  def >>>(x: Int): Int
417.  def >>>(x: Int): Int
418.  def ^(x: Long): Long
419.  def ^(x: Int): Long
420.  def ^(x: Char): Long
421.  def ^(x: Short): Long
422.  def ^(x: Byte): Long
423.  def ^(x: Long): Long
424.  def ^(x: Int): Int
425.  def ^(x: Char): Int
426.  def ^(x: Short): Int
427.  def ^(x: Byte): Int
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 equals(arg0: AnyRef): Boolean
434.  def hashCode(): Int
435.  def toByte: Byte
436.  def toByte: Byte
437.  def toByte: Byte
438.  def toByte: Byte
439.  def toByte: Byte
440.  def toByte: Byte
441.  def toChar: Char
442.  def toChar: Char
443.  def toChar: Char
444.  def toChar: Char
445.  def toChar: Char
446.  def toChar: Char
447.  def toDouble: Double
448.  def toDouble: Double
449.  def toDouble: Double
450.  def toDouble: Double
451.  def toDouble: Double
452.  def toDouble: Double
453.  def toFloat: Float
454.  def toFloat: Float
455.  def toFloat: Float
456.  def toFloat: Float
457.  def toFloat: Float
458.  def toFloat: Float
459.  def toInt: Int
460.  def toInt: Int
461.  def toInt: Int
462.  def toInt: Int
463.  def toInt: Int
464.  def toInt: Int
465.  def toLong: Long
466.  def toLong: Long
467.  def toLong: Long
468.  def toLong: Long
469.  def toLong: Long
470.  def toLong: Long
471.  def toShort: Short
472.  def toShort: Short
473.  def toShort: Short
474.  def toShort: Short
475.  def toShort: Short
476.  def toShort: Short
477.  def toString(): String
478.  def toString(): String
479.  def unary_+: Double
480.  def unary_+: Float
481.  def unary_+: Long
482.  def unary_+: Int
483.  def unary_+: Int
484.  def unary_-: Double
485.  def unary_-: Float
486.  def unary_-: Long
487.  def unary_-: Int
488.  def unary_-: Int
489.  def unary_~: Long
490.  def unary_~: Int
491.  def unary_~: Int
492.  def |(x: Long): Long
493.  def |(x: Int): Long
494.  def |(x: Char): Long
495.  def |(x: Short): Long
496.  def |(x: Byte): Long
497.  def |(x: Long): Long
498.  def |(x: Int): Int
499.  def |(x: Char): Int
500.  def |(x: Short): Int
501.  def |(x: Byte): Int
502.  def |(x: Long): Long
503.  def |(x: Int): Int
504.  def |(x: Char): Int
505.  def |(x: Short): Int
506.  def |(x: Byte): Int

Deprecated Value Members

1.  def +(x: String): String
2.  def +(x: String): String
3.  def +(x: String): String
4.  def +(x: String): String
5.  def +(x: String): String
6.  def <<(x: Long): Int
7.  def <<(x: Long): Int
8.  def >>(x: Long): Int
9.  def >>(x: Long): Int
10.  def >>>(x: Long): Int
11.  def >>>(x: Long): Int
12.  def signum: Int
13.  def →[B](y: B): (Byte, B)

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