func (c MapStringFloat32) MapAsync(cb func(string, float32, chan [2]interface{}), maxConcurrency ...int) MapStringFloat32 {
	var maxConc = lists.DEFAULT_CONC
	if len(maxConcurrency) == 1 {
		maxConc = maxConcurrency[0]
	}
	mapChan := make(chan [2]interface{}, len(c))
	ret := make(map[string]float32, len(c))
	if maxConc > 0 {
		sent := 0
		received := 0
		doing := make(chan struct{}, maxConc)
		indexes := c.Indexes()
		for {
			var k string
			var v float32
			if len(indexes) > sent {
				k = indexes[sent]
				v = c[k]
			}
			if len(doing) < maxConc && sent < len(c) {
				go cb(k, v, mapChan)
				sent++
				if maxConc > 0 {
					doing <- struct{}{}
				}
			} else {
				intf := <-mapChan
				received++
				ret[intf[0].(string)] = intf[1].(float32)
				<-doing
				if received == sent {
					close(mapChan)
					return ret
				}
			}
		}
	} else {
		for k, v := range c {
			go cb(k, v, mapChan)
		}
		ct := 0
		for intf := range mapChan {
			ret[intf[0].(string)] = intf[1].(float32)
			ct++
			if ct == len(c) {
				close(mapChan)
			}
		}
	}
	return ret
}
MapAsync method creates a new slice with the results of calling a provided go routine on every element in the calling array.
Runs asynchronously and needs gives a chan []interface{} to return results.
To keep initial order, the first elemt of th []interface{} written to the chan must be the key. The second element muse be a string.
Returns a StringSlice (original type).
If you want to map to a slice of different type, see MapAsyncInterface.
package maps
import "github.com/francoispqt/lists"
type MapStringFloat32 map[string]float32
func (c MapStringFloat32) Contains(s float32) bool {
	for _, v := range c {
		if v == s {
			return true
		}
	}
	return false
}
func (c MapStringFloat32) ForEach(cb func(string, float32)) {
	for k, v := range c {
		cb(k, v)
	}
}
func (c MapStringFloat32) Map(cb func(string, float32) float32) MapStringFloat32 {
	var ret = make(map[string]float32, len(c))
	for k, v := range c {
		ret[k] = cb(k, v)
	}
	return ret
}
func (c MapStringFloat32) MapInterface(cb func(string, float32) interface{}) MapStringInterface {
	var ret = make(map[string]interface{}, len(c))
	for k, v := range c {
		ret[k] = cb(k, v)
	}
	return ret
}