Mirror of forum.nim-lang.org

217 :: openarray

• MFlamer (orginal) [2013-08-31T18:53:45+02:00] view original

  I'm having trouble getting procedures with openarray parameters to work.

  proc zipwithT1,T2,T3:auto =

  result = xs

  for i in low(xs)..high(xs):

  result[i] = f(xs[i],ys[i])

  return result

  proc pluser(x:int, y:int):int = x + y

  var zs = zipwith(pluser,[1,2,3],[1,2,3]))

  This code produces "Error: invalid type: 'openarray[int]'"

  Also, the reason I wrote the silly "pluser" procedure is because I get another error when I try to pass the + operator directly. Shouldn't I be able to do this?

  var zs = zipwith(+,[1,2,3],[1,2,3]))

  Thanks.

---

• Araq (orginal) [2013-08-31T19:20:10+02:00] view original

  The proper grammar would be: var zs = zipwith(`+`, [1,2,3], [1,2,3])

  You shouldn't be able to do this as the builtin + is not a real function, it's mapped to the CPUs add instruction. Welcome to the world of systems programming where leaky abstractions are used as an excuse for lazy compiler writers. ;-)

  There is sequtils.zip.

  The following works:

  
  
  proc zipwith[T1,T2,T3](f: proc(a:T1,b:T2):T3, xs:openarray[T1],
                          ys:openarray[T2]): seq[T1] =
      newSeq(result, xs.len)
      for i in low(xs)..high(xs):
          result[i] = f(xs[i],ys[i])
  
  proc pluser(x:int, y:int):int = x + y
  
  var zs = zipwith(pluser,[1,2,3],[1,2,3])
  Run

---

• MFlamer (orginal) [2013-09-01T02:03:55+02:00] view original

  Thanks for the clarification. I guess the size of the array must be able to be determined at compile time, or we must use a sequence. Is a sequence like an array on the heap (contiguous address) or is it like a tree structure (like a sequence in a functional language)? I'm just wondering what sort of performance characteristics to expect. Thanks again.

---

• Araq (orginal) [2013-09-01T09:11:28+02:00] view original

  Thanks for the clarification. I guess the size of the array must be able to be determined at compile time, or we must use a sequence.

  Exactly. A sequence is an array on the heap.

---

• Krux02 (orginal) [2017-01-27T18:02:27+01:00] view original

  When you use templates, you can also use +.

  template zipwith[T1,T2](f: untyped; xs:openarray[T1], ys:openarray[T2]): untyped =
    let N = min(xs.len, ys.len)
    var res = newSeq[type(f(xs[0],ys[0]))](N)
    
    for i, value in res.mpairs:
      value = f(xs[i], ys[i])
    
    res
  
  var zs = zipwith(`+`,[1,2,3],[1,2,3])
  
  echo zs
  Run

---