How can I range over a channel of unknown types in golang

I have a function which receives a string and based on that it creates a channel of a type based on the string value. This channel is then sent off to be populated in another thread.

In this function, I then want to range over the populated values and use them.

However, I get an error: "cannot range over myChan (type interface {})"

Here is an example of my code:

func myFunc(input string) {
    var myChan interface{}

    switch input {
    case "one":
	    myChan = make(chan One)
    case "two":
	    myChan = make(chan Two)
    }

    go doStuff(&myChan)

	for _, item := range myChan {
    	fmt.Println(item)
    }
}

Please help me understand how to accomplish this?

Edit: I'm sorry my question was not clear enough. The line go doStuff(&myChan) is actually this:

go gocsv.UnmarshalToChan(clientsFile, &myChan)

According to the documentation of gocsv UnmarshalToChan "The channel must have a concrete type." That is why I cannot have a chan interface{}

myChan variable isn't a channel, a type channel is created in this way: chan interface{}

for example if you want a channel to pass any type you can use this:

func main() {
	c := make(chan interface{}, 1)
	
	go func() {
		for a := range c {
			fmt.Println(a)
		}
	}()
	
	c <- 21
	c <- "jazz"
	c <- person{"Chet", 88}

	time.Sleep(time.Second)
}

type person struct {
	Name string
	Age int
}

full example: https://play.golang.org/p/BJrAHiSAaw

I'm not 100% sure I understand the question, but looking at the code you've written, this is how I would get resolve the cannot range issue. This is going to deadlock, because not everything is defined...but ranging isn't an issue or shouldn't be. Also the doStuff code, should signal when the channel should be closed, maybe passed in a wait group, keep track with a counter, etc.

package main

import (
	"fmt"
	"log"
)

// One ...
type One struct{}

// Two ...
type Two struct{}

func doStuff(*interface{}) {}

func myFunc(input string) {
	var myChan interface{}
	switch input {
	case "one":
		myChan = make(chan One)
	case "two":
		myChan = make(chan Two)
	}
    // might have to move this line of code into the switch block below...
    // see commented example
	go doStuff(&myChan)

	switch myChan.(type) {
	case chan One:
        // in this way you're not passing an interface{} but a chan or type One or Two
        // go doStuff(&myChan.(chan One))
		for item := range myChan.(chan One) {
			fmt.Println(item)
		}
	case chan Two:
        // go doStuff(&myChan.(chan One))
		for item := range myChan.(chan Two) {
			fmt.Println(item)
		}
	default:
		log.Fatalln("Unknown type entered")
	}

}

func main() {
	myFunc("one")
}