Handling multiple-value in single-value context with csv read

[hyousef (Hasan Yousef)]

Trying to read date and number from csv file, so I’ve the below struct

type Transaction struct {
	Warehouse string    `json:"warehouse"`
	Item      string    `json:"item"`
	Movement  string    `json:"movement"`
	Batch     string    `json:"batch"`
	Date      time.Time `json:"transaction_data"`
	Quantity  uint64    `json:"quantity"`
}

type Transactions struct {
	header []string
	lines  []Transaction
}

And do the reading as below:

func main() {
	// Reading csv file thread > START //
	pairs := []Pair{{"m", 1}, {"d", 0}, {"c", 2}}
	fmt.Println(pairs)
	// Sort by Key
	sort.Sort(ByKey(pairs))
	fmt.Println(pairs)
	pairs = append(pairs, Pair{"h", 5})
	fmt.Println(pairs)

	// Reading csv file thread > START //
	input := make(chan Transactions)
	go func(input_file string) {
		var trx Transactions
		fr, err := os.Open(input_file)
		failOnError(err)
		defer fr.Close()
		r := csv.NewReader(fr)
		rows, err := r.ReadAll()
		failOnError(err)
		trx.header = rows[0]
		for _, row := range rows[1:] {
			trx.lines = append(trx.lines, Transaction{
				Warehouse: strings.TrimSpace(row[0]),
				Item:      strings.TrimSpace(row[1]),
				Movement:  strings.TrimSpace(row[2]),
				Batch:     strings.TrimSpace(row[3]),
				Date:      time.Parse("%Y-%m-%d", row[4]),                   // multiple-value in single-value context error
				Quantity:  (strconv.ParseFloat(row[5], 64) * 1000).(uint64),  // multiple-value in single-value context error
			})
		}

		peopleJson, _ := json.Marshal(trx.lines)
		fmt.Println(string(peopleJson)) 

		input <- trx // send data to channel read
	}("trx.csv")
	<-input // rceive from channel 'read' and assign value to new data variable
	// Reading csv file thread < END //
}

And got 2 errors:

.\pair.go:73:24: multiple-value time.Parse() in single-value context
.\pair.go:74:34: multiple-value strconv.ParseFloat() in single-value context

I understand the reason, which is both time.Parse() and strconv.ParseFloat() returning 2 outputs, value and error, and can overcome this issue by writing:

date, _ := time.Parse("%Y-%m-%d", row[4])
// and later:
Date:      date,

But I’m wondering if I can avoid this, and get it resolved within the same command block:

trx.lines = append(trx.lines, Transaction{
				Warehouse: strings.TrimSpace(row[0]),
				Item:      strings.TrimSpace(row[1]),
				Movement:  strings.TrimSpace(row[2]),
				Batch:     strings.TrimSpace(row[3]),
				Date:      ...
                Quantity:  ...
}

[skillian (Sean Killian)]

for _, row := range rows[1:] {
	date, err := time.Parse("2006-01-02", row[4])
	failOnError(err)
	f, err := strconv.ParseFloat(row[5], 64)
	failOnError(err)
	trx.lines = append(trx.lines, Transaction{
		Warehouse: strings.TrimSpace(row[0]),
		Item:      strings.TrimSpace(row[1]),
		Movement:  strings.TrimSpace(row[2]),
		Batch:     strings.TrimSpace(row[3]),
		Date:      date,
		Quantity:  (f * 1000).(uint64),
	})
}

Is how I would do this. An alternative could be for you to create a closure:

parseDate := func(v string) time.Time {
	t, err := time.Parse("2006-01-02", v)
	failOnError(err)
	return t
}

// ...
Date: parseDate(row[4])
// ...