code: func (c *Client) Subscribe(ctx context.Context, namespace string, channel interface{}, args ...interface{}) (*ClientSubscription, error) {
  	// Check type of channel first.
  	chanVal := reflect.ValueOf(channel)
  	if chanVal.Kind() != reflect.Chan || chanVal.Type().ChanDir()&reflect.SendDir == 0 {
  		panic("first argument to Subscribe must be a writable channel")
  	}
  	if chanVal.IsNil() {
  		panic("channel given to Subscribe must not be nil")
  	}
  	if c.isHTTP {
  		return nil, ErrNotificationsUnsupported
  	}
  
  	msg, err := c.newMessage(namespace+subscribeMethodSuffix, args...)
  	if err != nil {
  		return nil, err
  	}
  	op := &requestOp{
  		ids:  []json.RawMessage{msg.ID},
  		resp: make(chan *jsonrpcMessage),
  		sub:  newClientSubscription(c, namespace, chanVal),
  	}
  
  	// Send the subscription request.
  	// The arrival and validity of the response is signaled on sub.quit.
  	if err := c.send(ctx, op, msg); err != nil {
  		return nil, err
  	}
  	if _, err := op.wait(ctx, c); err != nil {
  		return nil, err
  	}
  	return op.sub, nil
  }
docs: // Subscribe calls the "<namespace>_subscribe" method with the given arguments,
  // registering a subscription. Server notifications for the subscription are
  // sent to the given channel. The element type of the channel must match the
  // expected type of content returned by the subscription.
  //
  // The context argument cancels the RPC request that sets up the subscription but has no
  // effect on the subscription after Subscribe has returned.
  //
  // Slow subscribers will be dropped eventually. Client buffers up to 8000 notifications
  // before considering the subscriber dead. The subscription Err channel will receive
  // ErrSubscriptionQueueOverflow. Use a sufficiently large buffer on the channel or ensure
  // that the channel usually has at least one reader to prevent this issue.