// Or implements Or with other conditions
424708
func (eq Eq) Or(conds ...Cond) Cond {
	return Or(eq, Or(conds...))
}
230510
func (n *Namespace) Conditional(condition bool, a, b interface{}) interface{} {
	if condition {
		return a
	}
	return b
}
267908
func (not Not) Or(conds ...Cond) Cond {
	return Or(not, Or(conds...))
}
484510
func (session *Session) Or(query interface{}, args ...interface{}) *Session {
	session.statement.Or(query, args...)
	return session
}
1347082
func (m MultiError) any(pred func(Error) bool) bool {
	for _, e := range m {
		if ourErr, ok := e.(Error); ok && pred(ourErr) {
			return true
		}
	}
	return false
}
602638
func Any(slice []string, handler func(string) bool) bool {
	for _, element := range slice {
		if handler(element) {
			return true
		}
	}
	return false
}
1211996
func (b *Builder) Or(cond Cond) *Builder {
	b.cond = Or(b.cond, cond)
	return b
}
939423
func (qb *MySQLQueryBuilder) Or(cond string) QueryBuilder {
	qb.Tokens = append(qb.Tokens, "OR", cond)
	return qb
}
248417
func (s *DB) Or(query interface{}, args ...interface{}) *DB {
	return s.clone().search.Or(query, args...).db
}
1256397
func If(condition bool, condTrue Cond, condFalse ...Cond) Cond {
	var c = condIf{
		condition: condition,
		condTrue:  condTrue,
	}
	if len(condFalse) > 0 {
		c.condFalse = condFalse[0]
	}
	return c
}
82771
func (o Opt) And(other Opt) Opt {
	if o == nil {
		if other == nil {
			return nil
		}
		return other
	}
	if other == nil {
		return o
	}
	return Opts{o, other}.Merged()
}
515909
func (c Condition) And(condition ...Condition) Condition {
	if c.None() && len(condition) == 1 {
		return condition[0]
	} else if c.Type == ConditionAnd {
		c.Inner = append(c.Inner, condition...)
		return c
	}

	inner := append([]Condition{c}, condition...)
	return And(inner...)
}
360983
func (f *FilterOp) Or(filters ...*FilterOp) *FilterOp {
	if len(f.OrFilters) == 0 {
		f.OrFilters = filters[:]
	} else {
		f.OrFilters = append(f.OrFilters, filters...)
	}

	return f
}
654389
func (q *Query) Or(query *Query) *Query {
	if query.skip != 0 || query.limit != 0 {
		panic("Or'd queries cannot contain skip or limit values")
	}
	q.ors = append(q.ors, query)
	return q
}
793718
func ord(thread *Thread, _ *Builtin, args Tuple, kwargs []Tuple) (Value, error) {
	if len(kwargs) > 0 {
		return nil, fmt.Errorf("ord does not accept keyword arguments")
	}
	if len(args) != 1 {
		return nil, fmt.Errorf("ord: got %d arguments, want 1", len(args))
	}
	s, ok := AsString(args[0])
	if !ok {
		return nil, fmt.Errorf("ord: got %s, want string", args[0].Type())
	}
	r, sz := utf8.DecodeRuneInString(s)
	if sz == 0 || sz != len(s) {
		n := utf8.RuneCountInString(s)
		return nil, fmt.Errorf("ord: string encodes %d Unicode code points, want 1", n)
	}
	return MakeInt(int(r)), nil
}
857426
func Or(lhs, rhs *cb.SignaturePolicy) *cb.SignaturePolicy {
	return NOutOf(1, []*cb.SignaturePolicy{lhs, rhs})
}
948834
func (e Error) If(fn func(error)) {
	if e.Present() {
		fn(*e.value)
	}
}