slice.got

package slice(type a, type b a)

// Here we have some utility slice routines

// Map1 provides an in-place map, meaning it modifies its input slice.
// If you still want that data, use the Map function.
func Map1(f func(a) a, slice []a) {
	for i,v := range slice {
		slice[i] = f(v)
	}
}

// Map provides an out-of-place map, meaning it does not modify its
// input slice.  It therefore has the advantage that you can Map from
// one type of slice to another.
func Map(f func(a) b, slice []a) []b {
	out := make([]b, len(slice))
	for i,v := range slice {
		out[i] = f(v)
	}
	return out
}

func Fold(f func(b, a) b, x b, slice []a) b {
  for _, v := range slice {
    x = f(x, v)
  }
  return x
}

// Filter returns a slice containing only those elements for which the
// predicate function returns true.
func Filter(f func(a) bool, slice []a) []a {
	out := make ([]a, 0, len(slice))
	i := 0
	for _,v := range slice {
		if f(v) {
			out = out[0:i+1]
			out[i] = v
			i++
		}
	}
	return out
}

// Append appends an element to a slice, in-place if possible, and
// expanding if needed.
func Append(slice []a, val a) []a {
	length := len(slice)
	if cap(slice) == length {
		// we need to expand
		newsl := make([]a, length, 2*(length+1))
		for i,v := range slice {
			newsl[i] = v
		}
		slice = newsl
	}
	slice = slice[0:length+1]
	slice[length] = val
	return slice
}

func Repeat(val a, n int) []a {
	out := make([]a, n)
	for i,_ := range out { out[i] = val }
	return out
}

// Cat concatenates two slices, expanding if needed.
func Cat(slices ...[]a) []a {
	return Cats(slices)
}

// Cats concatenates several slices, expanding if needed.
func Cats(slices [][]a) []a {
	lentot := 0
	for _,sl := range slices {
		lentot += len(sl)
	}
	out := make([]a, lentot)
	i := 0
	for _,sl := range slices {
		for _,v := range sl {
			out[i] = v
			i++
		}
	}
	return out
}

func Reverse(slice []a) (out []a) {
	ln := len(slice)
	out = make([]a, ln)
	for i,v:= range slice {
		out[ln-1-i] = v
	}
	return
}

func Any(f func(a) bool, slice []a) bool {
	for _,v:= range slice {
		if f(v) { return true }
	}
	return false
}