rust/src/test/ui/parser/recover-range-pats.stderr

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:21:12
   |
LL |     if let .0..Y = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:23:16
   |
LL |     if let X.. .0 = 0 {}
   |                ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:34:12
   |
LL |     if let .0..=Y = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:36:16
   |
LL |     if let X..=.0 = 0 {}
   |                ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:49:12
   |
LL |     if let .0...Y = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:52:17
   |
LL |     if let X... .0 = 0 {}
   |                 ^^ help: must have an integer part: `0.0`

error: `X..` range patterns are not supported
  --> $DIR/recover-range-pats.rs:58:12
   |
LL |     if let 0.. = 0 {}
   |            ^^^ help: try using the maximum value for the type: `0..MAX`

error: `X..` range patterns are not supported
  --> $DIR/recover-range-pats.rs:61:12
   |
LL |     if let X.. = 0 {}
   |            ^^^ help: try using the maximum value for the type: `X..MAX`

error: `X..` range patterns are not supported
  --> $DIR/recover-range-pats.rs:64:12
   |
LL |     if let true.. = 0 {}
   |            ^^^^^^ help: try using the maximum value for the type: `true..MAX`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:67:12
   |
LL |     if let .0.. = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: `X..` range patterns are not supported
  --> $DIR/recover-range-pats.rs:67:12
   |
LL |     if let .0.. = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `0.0..MAX`

error: `X..=` range patterns are not supported
  --> $DIR/recover-range-pats.rs:74:12
   |
LL |     if let 0..= = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `0..=MAX`

error: `X..=` range patterns are not supported
  --> $DIR/recover-range-pats.rs:77:12
   |
LL |     if let X..= = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `X..=MAX`

error: `X..=` range patterns are not supported
  --> $DIR/recover-range-pats.rs:80:12
   |
LL |     if let true..= = 0 {}
   |            ^^^^^^^ help: try using the maximum value for the type: `true..=MAX`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:83:12
   |
LL |     if let .0..= = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: `X..=` range patterns are not supported
  --> $DIR/recover-range-pats.rs:83:12
   |
LL |     if let .0..= = 0 {}
   |            ^^^^^ help: try using the maximum value for the type: `0.0..=MAX`

error: `X...` range patterns are not supported
  --> $DIR/recover-range-pats.rs:90:12
   |
LL |     if let 0... = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `0...MAX`

error: `X...` range patterns are not supported
  --> $DIR/recover-range-pats.rs:94:12
   |
LL |     if let X... = 0 {}
   |            ^^^^ help: try using the maximum value for the type: `X...MAX`

error: `X...` range patterns are not supported
  --> $DIR/recover-range-pats.rs:98:12
   |
LL |     if let true... = 0 {}
   |            ^^^^^^^ help: try using the maximum value for the type: `true...MAX`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:102:12
   |
LL |     if let .0... = 0 {}
   |            ^^ help: must have an integer part: `0.0`

error: `X...` range patterns are not supported
  --> $DIR/recover-range-pats.rs:102:12
   |
LL |     if let .0... = 0 {}
   |            ^^^^^ help: try using the maximum value for the type: `0.0...MAX`

error: `..X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:110:12
   |
LL |     if let ..0 = 0 {}
   |            ^^^ help: try using the minimum value for the type: `MIN..0`

error: `..X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:113:12
   |
LL |     if let ..Y = 0 {}
   |            ^^^ help: try using the minimum value for the type: `MIN..Y`

error: `..X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:116:12
   |
LL |     if let ..true = 0 {}
   |            ^^^^^^ help: try using the minimum value for the type: `MIN..true`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:119:15
   |
LL |     if let .. .0 = 0 {}
   |               ^^ help: must have an integer part: `0.0`

error: `..X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:119:12
   |
LL |     if let .. .0 = 0 {}
   |            ^^^^^ help: try using the minimum value for the type: `MIN..0.0`

error: `..=X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:126:12
   |
LL |     if let ..=3 = 0 {}
   |            ^^^^ help: try using the minimum value for the type: `MIN..=3`

error: `..=X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:129:12
   |
LL |     if let ..=Y = 0 {}
   |            ^^^^ help: try using the minimum value for the type: `MIN..=Y`

error: `..=X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:132:12
   |
LL |     if let ..=true = 0 {}
   |            ^^^^^^^ help: try using the minimum value for the type: `MIN..=true`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:135:15
   |
LL |     if let ..=.0 = 0 {}
   |               ^^ help: must have an integer part: `0.0`

error: `..=X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:135:12
   |
LL |     if let ..=.0 = 0 {}
   |            ^^^^^ help: try using the minimum value for the type: `MIN..=0.0`

error: `...X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:142:12
   |
LL |     if let ...3 = 0 {}
   |            ^^^^ help: try using the minimum value for the type: `MIN...3`

error: `...X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:146:12
   |
LL |     if let ...Y = 0 {}
   |            ^^^^ help: try using the minimum value for the type: `MIN...Y`

error: `...X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:150:12
   |
LL |     if let ...true = 0 {}
   |            ^^^^^^^ help: try using the minimum value for the type: `MIN...true`

error: float literals must have an integer part
  --> $DIR/recover-range-pats.rs:154:15
   |
LL |     if let ....3 = 0 {}
   |               ^^ help: must have an integer part: `0.3`

error: `...X` range patterns are not supported
  --> $DIR/recover-range-pats.rs:154:12
   |
LL |     if let ....3 = 0 {}
   |            ^^^^^ help: try using the minimum value for the type: `MIN...0.3`

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:58:12
   |
LL |     if let 0.. = 0 {}
   |            ^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:61:12
   |
LL |     if let X.. = 0 {}
   |            ^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:64:12
   |
LL |     if let true.. = 0 {}
   |            ^^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:67:12
   |
LL |     if let .0.. = 0 {}
   |            ^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:74:12
   |
LL |     if let 0..= = 0 {}
   |            ^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:77:12
   |
LL |     if let X..= = 0 {}
   |            ^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:80:12
   |
LL |     if let true..= = 0 {}
   |            ^^^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:83:12
   |
LL |     if let .0..= = 0 {}
   |            ^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:90:12
   |
LL |     if let 0... = 0 {}
   |            ^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:94:12
   |
LL |     if let X... = 0 {}
   |            ^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:98:12
   |
LL |     if let true... = 0 {}
   |            ^^^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:102:12
   |
LL |     if let .0... = 0 {}
   |            ^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:110:12
   |
LL |     if let ..0 = 0 {}
   |            ^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:113:12
   |
LL |     if let ..Y = 0 {}
   |            ^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:116:12
   |
LL |     if let ..true = 0 {}
   |            ^^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:119:12
   |
LL |     if let .. .0 = 0 {}
   |            ^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:126:12
   |
LL |     if let ..=3 = 0 {}
   |            ^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:129:12
   |
LL |     if let ..=Y = 0 {}
   |            ^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:132:12
   |
LL |     if let ..=true = 0 {}
   |            ^^^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:135:12
   |
LL |     if let ..=.0 = 0 {}
   |            ^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:142:12
   |
LL |     if let ...3 = 0 {}
   |            ^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:146:12
   |
LL |     if let ...Y = 0 {}
   |            ^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:150:12
   |
LL |     if let ...true = 0 {}
   |            ^^^^^^^

error: arbitrary expressions aren't allowed in patterns
  --> $DIR/recover-range-pats.rs:154:12
   |
LL |     if let ....3 = 0 {}
   |            ^^^^^

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:41:13
   |
LL |     if let 0...3 = 0 {}
   |             ^^^ help: use `..=` for an inclusive range
   |
note: lint level defined here
  --> $DIR/recover-range-pats.rs:7:9
   |
LL | #![deny(ellipsis_inclusive_range_patterns)]
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:42:13
   |
LL |     if let 0...Y = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:43:13
   |
LL |     if let X...3 = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:44:13
   |
LL |     if let X...Y = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:45:16
   |
LL |     if let true...Y = 0 {}
   |                ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:47:13
   |
LL |     if let X...true = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:49:14
   |
LL |     if let .0...Y = 0 {}
   |              ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:52:13
   |
LL |     if let X... .0 = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:90:13
   |
LL |     if let 0... = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:94:13
   |
LL |     if let X... = 0 {}
   |             ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:98:16
   |
LL |     if let true... = 0 {}
   |                ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:102:14
   |
LL |     if let .0... = 0 {}
   |              ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:142:12
   |
LL |     if let ...3 = 0 {}
   |            ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:146:12
   |
LL |     if let ...Y = 0 {}
   |            ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:150:12
   |
LL |     if let ...true = 0 {}
   |            ^^^ help: use `..=` for an inclusive range

error: `...` range patterns are deprecated
  --> $DIR/recover-range-pats.rs:154:12
   |
LL |     if let ....3 = 0 {}
   |            ^^^ help: use `..=` for an inclusive range

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:19:12
   |
LL |     if let true..Y = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: u8

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:20:15
   |
LL |     if let X..true = 0 {}
   |               ^^^^ ranges require char or numeric types
   |
   = note: start type: u8
   = note: end type: bool

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:21:12
   |
LL |     if let .0..Y = 0 {}
   |            ^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:23:12
   |
LL |     if let X.. .0 = 0 {}
   |            ^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `u8`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:32:12
   |
LL |     if let true..=Y = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: u8

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:33:16
   |
LL |     if let X..=true = 0 {}
   |                ^^^^ ranges require char or numeric types
   |
   = note: start type: u8
   = note: end type: bool

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:34:12
   |
LL |     if let .0..=Y = 0 {}
   |            ^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:36:12
   |
LL |     if let X..=.0 = 0 {}
   |            ^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `u8`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:45:12
   |
LL |     if let true...Y = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: u8

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:47:16
   |
LL |     if let X...true = 0 {}
   |                ^^^^ ranges require char or numeric types
   |
   = note: start type: u8
   = note: end type: bool

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:49:12
   |
LL |     if let .0...Y = 0 {}
   |            ^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `{integer}`
              found type `{float}`

error[E0308]: mismatched types
  --> $DIR/recover-range-pats.rs:52:12
   |
LL |     if let X... .0 = 0 {}
   |            ^^^^^^^ expected integer, found floating-point number
   |
   = note: expected type `u8`
              found type `{float}`

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:58:12
   |
LL |     if let 0.. = 0 {}
   |            ^^^ ranges require char or numeric types
   |
   = note: start type: {integer}
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:61:12
   |
LL |     if let X.. = 0 {}
   |            ^^^ ranges require char or numeric types
   |
   = note: start type: u8
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:64:12
   |
LL |     if let true.. = 0 {}
   |            ^^^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:67:12
   |
LL |     if let .0.. = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: {float}
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:74:12
   |
LL |     if let 0..= = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: {integer}
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:77:12
   |
LL |     if let X..= = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: u8
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:80:12
   |
LL |     if let true..= = 0 {}
   |            ^^^^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:83:12
   |
LL |     if let .0..= = 0 {}
   |            ^^^^^ ranges require char or numeric types
   |
   = note: start type: {float}
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:90:12
   |
LL |     if let 0... = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: {integer}
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:94:12
   |
LL |     if let X... = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: u8
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:98:12
   |
LL |     if let true... = 0 {}
   |            ^^^^^^^ ranges require char or numeric types
   |
   = note: start type: bool
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:102:12
   |
LL |     if let .0... = 0 {}
   |            ^^^^^ ranges require char or numeric types
   |
   = note: start type: {float}
   = note: end type: [type error]

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:110:12
   |
LL |     if let ..0 = 0 {}
   |            ^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: {integer}

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:113:12
   |
LL |     if let ..Y = 0 {}
   |            ^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: u8

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:116:12
   |
LL |     if let ..true = 0 {}
   |            ^^^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: bool

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:119:12
   |
LL |     if let .. .0 = 0 {}
   |            ^^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: {float}

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:126:12
   |
LL |     if let ..=3 = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: {integer}

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:129:12
   |
LL |     if let ..=Y = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: u8

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:132:12
   |
LL |     if let ..=true = 0 {}
   |            ^^^^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: bool

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:135:12
   |
LL |     if let ..=.0 = 0 {}
   |            ^^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: {float}

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:142:12
   |
LL |     if let ...3 = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: {integer}

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:146:12
   |
LL |     if let ...Y = 0 {}
   |            ^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: u8

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:150:12
   |
LL |     if let ...true = 0 {}
   |            ^^^^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: bool

error[E0029]: only char and numeric types are allowed in range patterns
  --> $DIR/recover-range-pats.rs:154:12
   |
LL |     if let ....3 = 0 {}
   |            ^^^^^ ranges require char or numeric types
   |
   = note: start type: [type error]
   = note: end type: {float}

error: aborting due to 112 previous errors

Some errors have detailed explanations: E0029, E0308.
For more information about an error, try `rustc --explain E0029`.