golang: Mark chan<T> IO methods as const

chan<T> is a pointer type and e.g. send does not change the pointer - it
only "modifies" channel buffer. Marking appropriate methods as const is
needed so that `const chan<T>` could be used to send/receive the same
way as `chan <T>` is used.

golang/_golang.pxd

@@ -70,28 +70,28 @@ cdef extern from "golang/libgolang.h" namespace "golang" nogil:
         chan();
 
         # send/recv/close
-        void send(const T&)
-        T recv()
-        pair[T, cbool] recv_()
-        void close()
+        void send(const T&)                 const
+        T recv()                            const
+        pair[T, cbool] recv_()              const
+        void close()                        const
 
         # send/recv in select
-        _selcase sends(const T *ptx)
-        _selcase recvs()
-        _selcase recvs(T* prx)
-        _selcase recvs(T* prx, cbool *pok)
+        _selcase sends(const T *ptx)        const
+        _selcase recvs()                    const
+        _selcase recvs(T* prx)              const
+        _selcase recvs(T* prx, cbool *pok)  const
 
         # length/capacity
-        unsigned len()
-        unsigned cap()
+        unsigned len()                      const
+        unsigned cap()                      const
 
         # compare wrt nil; =nil
-        cbool operator==(nullptr_t)
-        cbool operator!=(nullptr_t)
+        cbool operator==(nullptr_t)         const
+        cbool operator!=(nullptr_t)         const
         void operator=(nullptr_t)
 
         # for tests
-        _chan *_rawchan()
+        _chan *_rawchan()   const
 
     chan[T] makechan[T]()
     chan[T] makechan[T](unsigned size)

golang/libgolang.h

@@ -316,39 +316,39 @@ public:
     static_assert(std::is_trivially_copyable<T>::value, "TODO chan<T>: T copy is not trivial");
 
     // send/recv/close
-    inline void send(const T &ptx)     { _chansend(_ch, &ptx);                  }
-    inline T recv()                    { T rx; _chanrecv(_ch, &rx); return rx;  }
-    inline std::pair<T,bool> recv_()   { T rx; bool ok = _chanrecv_(_ch, &rx);
-                                         return std::make_pair(rx, ok);         }
-    inline void close()                { _chanclose(_ch);                       }
+    inline void send(const T &ptx)    const  { _chansend(_ch, &ptx);                  }
+    inline T recv()                   const  { T rx; _chanrecv(_ch, &rx); return rx;  }
+    inline std::pair<T,bool> recv_()  const  { T rx; bool ok = _chanrecv_(_ch, &rx);
+                                               return std::make_pair(rx, ok);         }
+    inline void close()               const  { _chanclose(_ch);                       }
 
     // send/recv in select
 
     // ch.sends creates `ch.send(*ptx)` case for select.
-    [[nodiscard]] inline _selcase sends(const T *ptx) { return _selsend(_ch, ptx); }
+    [[nodiscard]] inline _selcase sends(const T *ptx) const { return _selsend(_ch, ptx); }
 
     // ch.recvs creates `*prx = ch.recv()` case for select.
     //
     // if pok is provided the case is extended to `[*prx, *pok] = ch.recv_()`
     // if both prx and pok are omitted the case is reduced to `ch.recv()`.
-    [[nodiscard]] inline _selcase recvs(T *prx=NULL, bool *pok=NULL) {
+    [[nodiscard]] inline _selcase recvs(T *prx=NULL, bool *pok=NULL) const {
         return _selrecv_(_ch, prx, pok);
     }
 
     // length/capacity
-    inline unsigned len()              { return _chanlen(_ch);         }
-    inline unsigned cap()              { return _chancap(_ch);         }
+    inline unsigned len()             const  { return _chanlen(_ch); }
+    inline unsigned cap()             const  { return _chancap(_ch); }
 
     // compare wrt nil
-    inline bool operator==(nullptr_t)  { return (_ch == NULL); }
-    inline bool operator!=(nullptr_t)  { return (_ch != NULL); }
+    inline bool operator==(nullptr_t) const  { return (_ch == NULL); }
+    inline bool operator!=(nullptr_t) const  { return (_ch != NULL); }
 
     // compare wrt chan
-    inline bool operator==(const chan<T>& ch2)	{ return (_ch == ch2._ch); }
-    inline bool operator!=(const chan<T>& ch2)  { return (_ch != ch2._ch); }
+    inline bool operator==(const chan<T>& ch2) const { return (_ch == ch2._ch); }
+    inline bool operator!=(const chan<T>& ch2) const { return (_ch != ch2._ch); }
 
     // for testing
-    inline _chan *_rawchan()           { return _ch; }
+    inline _chan *_rawchan() const     { return _ch; }
 };
 
 // makechan<T> makes new chan<T> with capacity=size.