improve json unmarshaling

assets.go

@@ -30,20 +30,20 @@ func (c *Client) AssetsSearch(search string, trim *TrimParams) ([]Asset, Timesta
 	}
 	trim.setTo(&q)
 
-	return requestArray[Asset](c, "assets", q)
+	return request[[]Asset](c, "assets", q)
 }
 
 // AssetsSearchByIDs returns a list of CoinCap assets.
 func (c *Client) AssetsSearchByIDs(ids []string) ([]Asset, Timestamp, error) {
 	if ids == nil {
 		return nil, 0, nil
 	}
-	return requestArray[Asset](c, "assets", url.Values{"ids": ids})
+	return request[[]Asset](c, "assets", url.Values{"ids": ids})
 }
 
 // AssetByID returns an asset by its ID.
 func (c *Client) AssetByID(id string) (*Asset, Timestamp, error) {
-	return request[Asset](c, "assets/"+id, nil)
+	return request[*Asset](c, "assets/"+id, nil)
 }
 
 // AssetHistory contains the USD price of an asset at a given timestamp.
@@ -59,7 +59,7 @@ func (c *Client) AssetHistory(id string, interval *IntervalParams) ([]AssetHisto
 	if err != nil {
 		return nil, 0, err
 	}
-	return requestArray[AssetHistory](c, "assets/"+id+"/history", q)
+	return request[[]AssetHistory](c, "assets/"+id+"/history", q)
 }
 
 // AssetMarket contains the markets info of an asset.
@@ -78,5 +78,5 @@ type AssetMarket struct {
 func (c *Client) AssetMarkets(id string, trim *TrimParams) ([]AssetMarket, Timestamp, error) {
 	q := make(url.Values)
 	trim.setTo(&q)
-	return requestArray[AssetMarket](c, "assets/"+id+"/markets", q)
+	return request[[]AssetMarket](c, "assets/"+id+"/markets", q)
 }

candles.go

@@ -48,5 +48,5 @@ func (c *Client) Candles(params CandlesRequest, interval *IntervalParams, trim *
 		return nil, 0, err
 	}
 	trim.setTo(&q)
-	return requestArray[Candle](c, "candles", q)
+	return request[[]Candle](c, "candles", q)
 }

coincap.go

@@ -38,12 +38,7 @@ type Client struct {
 	ws   *websocket.Dialer
 }
 
-func requestArray[T any](c *Client, endpoint string, query url.Values) ([]T, Timestamp, error) {
-	r, t, err := request[[]T](c, endpoint, query)
-	return *r, t, err
-}
-
-func request[T any](c *Client, endpoint string, query url.Values) (*T, Timestamp, error) {
+func request[T any](c *Client, endpoint string, query url.Values) (T, Timestamp, error) {
 	resp, err := c.http.Do(&http.Request{
 		Method: http.MethodGet,
 		URL: &url.URL{
@@ -54,28 +49,22 @@ func request[T any](c *Client, endpoint string, query url.Values) (*T, Timestamp
 		},
 	})
 	if err != nil {
-		return nil, 0, err
+		var t T
+		return t, 0, err
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode != http.StatusOK {
-		if resp.StatusCode == http.StatusNotFound {
-			return nil, 0, nil
-		}
-		return nil, 0, errors.New("unexpected http status code: " + resp.Status)
-	}
-
 	r, b, err := decodeJSON[struct {
-		Data      json.RawMessage `json:"data"`
-		Timestamp Timestamp       `json:"timestamp"`
+		Data      T         `json:"data"`
+		Timestamp Timestamp `json:"timestamp"`
 	}](resp.Body)
 
 	if err != nil {
-		return nil, 0, errors.New("coincap: unexpected response:\n" + string(b))
+		var t T
+		return t, 0, errors.New("coincap (" + resp.Status + "): " + string(b))
 	}
 
-	var v T
-	return &v, r.Timestamp, json.Unmarshal(r.Data, &v)
+	return r.Data, r.Timestamp, nil
 }
 
 func decodeJSON[T any](r io.Reader) (*T, []byte, error) {

exchanges.go

@@ -15,10 +15,10 @@ type Exchange struct {
 
 // Exchanges returns information about all exchanges currently tracked by CoinCap.
 func (c *Client) Exchanges() ([]Exchange, Timestamp, error) {
-	return requestArray[Exchange](c, "exchanges", nil)
+	return request[[]Exchange](c, "exchanges", nil)
 }
 
 // ExchangeByID returns exchange data for an exchange with the given unique ID.
 func (c *Client) ExchangeByID(id string) (*Exchange, Timestamp, error) {
-	return request[Exchange](c, "exchanges/"+id, nil)
+	return request[*Exchange](c, "exchanges/"+id, nil)
 }

markets.go

@@ -55,5 +55,5 @@ func (c *Client) Markets(params MarketsRequest, trim *TrimParams) ([]Market, Tim
 		q.Set("assetId", params.AssetID)
 	}
 
-	return requestArray[Market](c, "markets", q)
+	return request[[]Market](c, "markets", q)
 }

rates.go

@@ -12,10 +12,10 @@ type Rate struct {
 
 // Rates returns currency rates standardized in USD.
 func (c *Client) Rates() ([]Rate, Timestamp, error) {
-	return requestArray[Rate](c, "rates", nil)
+	return request[[]Rate](c, "rates", nil)
 }
 
 // RateByID returns the USD rate for the given asset identifier.
 func (c *Client) RateByID(id string) (*Rate, Timestamp, error) {
-	return request[Rate](c, "rates/"+id, nil)
+	return request[*Rate](c, "rates/"+id, nil)
 }

stream.go

@@ -28,7 +28,7 @@ type Trade struct {
 // response 'socket':true/false.
 // The trades websocket is the only way to receive individual
 // trade data through CoinCap.
-func (c *Client) Trades(exchange string) (*Stream[Trade], error) {
+func (c *Client) Trades(exchange string) (*Stream[*Trade], error) {
 	e, _, err := c.ExchangeByID(exchange)
 	if err != nil {
 		return nil, err
@@ -40,7 +40,7 @@ func (c *Client) Trades(exchange string) (*Stream[Trade], error) {
 		return nil, errors.New("exchange '" + exchange + "' does not support websockets")
 	}
 	const u = "wss://ws.coincap.io/trades/"
-	return dial[Trade](c.ws, u+exchange)
+	return dial[*Trade](c.ws, u+exchange)
 }
 
 // Price implements Unmarshaler interface for float64.
@@ -80,15 +80,15 @@ func (c *Client) Prices(assets ...string) (*Stream[map[string]Price], error) {
 // Stream streams data from websocket conneсtion.
 type Stream[T any] struct {
 	conn *websocket.Conn
-	ch   chan *T
+	ch   chan T
 	stop chan struct{}
 	mut  sync.Mutex
 	err  error
 }
 
 // DataChannel returns data channel.
 // It will be closed if there is an error or if the stream is closed.
-func (s *Stream[T]) DataChannel() <-chan *T {
+func (s *Stream[T]) DataChannel() <-chan T {
 	return s.ch
 }
 
@@ -128,7 +128,7 @@ func (s *Stream[T]) dial() {
 		select {
 		case <-s.stop:
 			return
-		case s.ch <- v:
+		case s.ch <- *v:
 		}
 	}
 	s.mut.Lock()
@@ -150,7 +150,7 @@ func dial[T any](ws *websocket.Dialer, u string) (*Stream[T], error) {
 
 	s := Stream[T]{
 		conn: conn,
-		ch:   make(chan *T),
+		ch:   make(chan T),
 		stop: make(chan struct{}),
 	}
 	go s.dial()

stream_test.go

@@ -85,7 +85,7 @@ func TestPrices(t *testing.T) {
 			t.Fatal(s.Err())
 		}
 
-		_, ok = (*d)["bitcoin"]
+		_, ok = d["bitcoin"]
 		if !ok {
 			t.Fatal("result has no expected field")
 		}