func (r Regexps) Range(f func(string) bool) bool {
	return r.RangeWithRunes(func(s []rune) bool {
		return f(string(s))
	})
}
Range all possibilities
package crun
import (
	"fmt"
	"log"
	"math/rand"
	"regexp/syntax"
	"time"
)
const MoreTimes = 18
type Regexp struct {
	Op       Op
	Sub      []Regexps
	Rune     []rune
	Min, Max int
}
type Regexps []*Regexp
func Compile(str string) (Regexps, error) {
	reg, err := syntax.Parse(str, syntax.Perl)
	if err != nil {
		return nil, fmt.Errorf("crun: Compile(%q): %w", str, err)
	}
	return NewRegexps(reg), nil
}
func MustCompile(str string) Regexps {
	reg, err := Compile(str)
	if err != nil {
		panic(err)
	}
	return reg
}
func NewRegexps(reg *syntax.Regexp) (out Regexps) {
	return std.NewRegexps(reg)
}
var std = &Optional{
	MoreTimes:    MoreTimes,
	AnyCharNotNL: []rune{33, 126},
	AnyChar:      []rune{33, 126},
}
type Optional struct {
	MoreTimes    int
	AnyCharNotNL []rune
	AnyChar      []rune
	Rand         Rand
}
func (o *Optional) NewRegexps(reg *syntax.Regexp) (out Regexps) {
	ff := func(rs ...*Regexp) {
		out = append(out, rs...)
	}
	switch reg.Op {
	case syntax.OpNoMatch:  
	case syntax.OpEmptyMatch:  
	case syntax.OpLiteral:  
		ff(&Regexp{
			Op:   OpLiteral,
			Rune: reg.Rune,
		})
	case syntax.OpCharClass:  
		ff(&Regexp{
			Op:   OpRepeat,
			Rune: reg.Rune,
			Max:  1,
			Min:  1,
		})
	case syntax.OpAnyCharNotNL:  
		ff(&Regexp{
			Op:   OpRepeat,
			Rune: o.AnyCharNotNL,
			Max:  1,
			Min:  1,
		})
	case syntax.OpAnyChar:  
		ff(&Regexp{
			Op:   OpRepeat,
			Rune: o.AnyChar,
			Max:  1,
			Min:  1,
		})
	case syntax.OpBeginLine:  
	case syntax.OpEndLine:  
	case syntax.OpBeginText:  
	case syntax.OpEndText:  
	case syntax.OpWordBoundary:  
	case syntax.OpNoWordBoundary:  
	case syntax.OpCapture:  
		for _, v := range reg.Sub {
			ff(o.NewRegexps(v)...)
		}
	case syntax.OpStar:  
		sub := make([]Regexps, 0, len(reg.Sub))
		for _, v := range reg.Sub {
			sub = append(sub, o.NewRegexps(v))
		}
		ff(&Regexp{
			Op:  OpRepeat,
			Sub: sub,
			Max: o.MoreTimes,
			Min: 0,
		})
	case syntax.OpPlus:  
		sub := make([]Regexps, 0, len(reg.Sub))
		for _, v := range reg.Sub {
			sub = append(sub, o.NewRegexps(v))
		}
		ff(&Regexp{
			Op:  OpRepeat,
			Sub: sub,
			Max: o.MoreTimes,
			Min: 1,
		})
	case syntax.OpQuest:  
		sub := make([]Regexps, 0, len(reg.Sub))
		for _, v := range reg.Sub {
			sub = append(sub, o.NewRegexps(v))
		}
		ff(&Regexp{
			Op:  OpRepeat,
			Sub: sub,
			Max: 1,
			Min: 0,
		})
	case syntax.OpRepeat:  
		sub := make([]Regexps, 0, len(reg.Sub))
		for _, v := range reg.Sub {
			sub = append(sub, o.NewRegexps(v))
		}
		ff(&Regexp{
			Op:  OpRepeat,
			Sub: sub,
			Max: reg.Max,
			Min: reg.Min,
		})
	case syntax.OpConcat:  
		for _, v := range reg.Sub {
			ff(o.NewRegexps(v)...)
		}
	case syntax.OpAlternate:  
		sub := make([]Regexps, 0, len(reg.Sub))
		for _, v := range reg.Sub {
			sub = append(sub, o.NewRegexps(v))
		}
		ff(&Regexp{
			Op:  OpAlternate,
			Sub: sub,
		})
	default:
		log.Printf("crun: unsupported op %v", reg.Op)
	}
	return out
}
func (r Regexps) Size() int {
	s := 0
	size(r, &s)
	return s
}