Mirror of forum.nim-lang.org

1070 :: Ranges and loop

• axben (orginal) [2015-03-25T17:42:17+01:00] view original

  Is there any possibility to shorten the following loop w/o omitting the two helper variables found and sr?

  var
     found = false
     rng: SomeRange
  
  for sr in SomeRange:
     if <some_condition>:
        found = true
        rng   = sr
        break
  
  if found:
     # Use rng
  Run

  In C I'd write this like so:

  int rng = LOW;
  
  while (rng < HIGH)
  {
     if (<some_condition>) break;
     rng++;
  }
  
  if (rng < HIGH)
     // Use rng
  Run

  I can't use this construct:

  var rng = SomeRange.low
  
  while rng < SomeRange.high:
     if <some_condition>: break
     inc rng
  
  if (rng < SomeRange.high)
     # Use rng
  Run

  As calling inc() on rng.high throws an error (this changed only recently).

---

• fowl (orginal) [2015-03-25T21:41:26+01:00] view original

  • calling on inc() on rng.high doesnt make sense. inc(rng) works though... BTW if you did not know range is a TYPE that means you can't change it at runtime

  const somecondition = true
  type MyRange = range[0..2]
  var x: MyRange
  while x < MyRange.high:
      if somecondition: break
      inc x
  if x == MyRange.high:
      discard
  echo x
  Run

  const somecondition = true
  
  type MyRange = range[0..2]
  var
      it: MyRange
      found:bool
  for itm in MyRange.low .. MyRange.high:
      if somecondition:
          found = true
          it = itm
          break
  if found:
      discard
  echo it
  Run

---

• axben (orginal) [2015-03-26T09:20:20+01:00] view original

  @fowl: Yes I know that range is a type. I tried to make clear that calling inc() on the maximum value of that range throws an error like in

  type SomeRange = [0..1]
  var rng = SomeRange.high
  inc rng
  Run

  Also, my third sample should read like so (too C-centric some times...):

  type SomeRange = range[0..1]
  var rng = SomeRange.low
  
  while rng <= SomeRange.high:
     if false: break
     inc rng
  
  if (rng <= SomeRange.high):
     # Use rng
  Run

  Sorry for that. I hope you get the idea NOW.

---

• Araq (orginal) [2015-03-26T09:27:10+01:00] view original

  var rng = SomeRange.low.int does the trick.

---

• axben (orginal) [2015-03-26T09:47:01+01:00] view original

  @Araq: But I loose type safety:

  import typetraits
  type SomeRange = range[0..1]
  var
     rng = SomeRange.high.int   # Now an int!
     ary: array[SomeRange, int]
  
  echo rng.type.name
  echo ary[rng + 1]  # Crashes on run!
  echo ary[2]        # Error on compile!
  Run

  What about something like this:

  var
     rng = SomeRange.oob   # Typesafe initializer to an "Out-of-bounds" value
  Run

---

• Araq (orginal) [2015-03-26T09:58:49+01:00] view original

  Well:

  var x = low(T)
  while x <= high(T):
    echo x
    inc x
  Run

  Needs to be replaced by something like this:

  var x = low(T).int
  while x <= high(T).int:
    echo x.T
    inc x
  Run

  This is most often wrapped up in an iterator so it's not too bad IMHO. Note that r <= high(r) and r >= low(r) always holds and so the compiler is free to optimize it away!

---

• axben (orginal) [2015-03-26T10:15:43+01:00] view original

  @Araq: I don't see how this invalidates the type safety argument. At the end of the loop x is an int that has a value out of the bounds of T (what about more complex T's, like tuples?). Introducing a "out-of-bounds value" which should be allowed only in explicit initializations, would IMHO be better.

---

• Araq (orginal) [2015-03-26T10:36:53+01:00] view original

  An out-of-bounds value is by definition not type safe either so I cannot follow you.

---

• axben (orginal) [2015-03-26T11:00:16+01:00] view original

  @Araq: I don't mean to be the pain in your arse, but how would I handle this w/o loosing type-safety? Right now we obviously have to rely on bounds checking to find out we forgot to check that some T.<cast> is out of T's bounds. Turning bounds checking off, we get no error whatsoever. Some code like the following will run when compiled with -d:release:

  type SomeRange = range['a'..'b']
  var
     rng = SomeRange.high.char
     ary: array[SomeRange, int]
  
  inc rng
  echo ary[rng]  # No longer crashes on run...
  Run

---

• Araq (orginal) [2015-03-26T11:23:30+01:00] view original

  Well you keep changing the topic! Now it's release vs debug mode. It's well known that -d:release trades correctness for speed. You test in debug mode and then turn on release for speed. If you need the speed.

  how would I handle this w/o loosing type-safety?

  type
    ArrayRange = 0..10
    IndexRange = -1..10
    Arr = array[ArrayRange, int]
  let i = IndexRange.low
  Run

---