code: func Parse(env []string) ([]Constraint, error) {
  	exprs := []Constraint{}
  	for _, e := range env {
  		found := false
  		// each expr is in the form of "key op value"
  		for i, op := range operators {
  			if !strings.Contains(e, op) {
  				continue
  			}
  			// split with the op
  			parts := strings.SplitN(e, op, 2)
  
  			if len(parts) < 2 {
  				return nil, fmt.Errorf("invalid expr: %s", e)
  			}
  
  			part0 := strings.TrimSpace(parts[0])
  			// validate key
  			matched := alphaNumeric.MatchString(part0)
  			if !matched {
  				return nil, fmt.Errorf("key '%s' is invalid", part0)
  			}
  
  			part1 := strings.TrimSpace(parts[1])
  
  			// validate Value
  			matched = valuePattern.MatchString(part1)
  			if !matched {
  				return nil, fmt.Errorf("value '%s' is invalid", part1)
  			}
  			// TODO(dongluochen): revisit requirements to see if globing or regex are useful
  			exprs = append(exprs, Constraint{key: part0, operator: i, exp: part1})
  
  			found = true
  			break // found an op, move to next entry
  		}
  		if !found {
  			return nil, fmt.Errorf("constraint expected one operator from %s", strings.Join(operators, ", "))
  		}
  	}
  	return exprs, nil
  }
docs: // Parse parses list of constraints.