func (g *Graph) GetBool(path string) (bool, error) {
	if len(path) == 0 {
		return g.Bool(), nil
	}
	i := g.Get(path)
	if i == nil {
		return false, errors.New("not found")
	}
	if i.Len() == 0 {
		return false, errors.New("Get() design error: not subnodes")
	}
	j, ok := _boolf(i.Out[0].This)
	if !ok {
		return false, errors.New("not a boolean")
	}
	return j, nil
}
GetBool returns the result of applying a path to the given Graph.
The result is returned as a bool. If the path result cannot be converted
to a boolean, then an error is returned.
package ogdl
import (
	"errors"
	"fmt"
	"math"
	"reflect"
	"regexp"
	"strconv"
)
func (g *Graph) Find(re string) (*Graph, error) {
	exp, err := regexp.Compile(re)
	if err != nil {
		return nil, err
	}
	r := New("_")
	for _, node := range g.Out {
		if exp.MatchString(node.ThisString()) {
			r.Add(node)
		}
	}
	return r, nil
}
func (g *Graph) Int64(def ...int64) int64 {
	n, ok := _int64f(g.String())
	if !ok {
		if len(def) == 0 {
			return 0
		}
		return def[0]
	}
	return n
}
func (g *Graph) Float64(def ...float64) float64 {
	n, ok := _float64f(g.String())
	if !ok {
		if len(def) == 0 {
			return math.NaN()
		}
		return def[0]
	}
	return n
}
func (g *Graph) Bool(def ...bool) bool {
	n, ok := _boolf(g.String())
	if !ok {
		if len(def) == 0 {
			return false
		}
		return def[0]
	}
	return n
}
func (g *Graph) ThisValue() reflect.Value {
	return reflect.ValueOf(g.This)
}
func (g *Graph) Value() reflect.Value {
	return reflect.ValueOf(g.Interface())
}
func (g *Graph) String(def ...string) string {
	if g == nil {
		if len(def) == 0 {
			return ""
		}
		return def[0]
	}
	return _string(g.Interface())
}
func (g *Graph) StringCSV(def ...string) string {
	if g == nil {
		if len(def) == 0 {
			return ""
		}
		return def[0]
	}
	s := ""
	for _, n := range g.Out {
		s += ", " + _string(n.This)
	}
	return s[2:]
}
func (g *Graph) ThisString(def ...string) string {
	if g == nil {
		if len(def) == 0 {
			return ""
		}
		return def[0]
	}
	return _string(g.This)
}
func (g *Graph) Bytes() []byte {
	return _bytes(g.Interface())
}
func (g *Graph) ThisBytes() []byte {
	return _bytes(g.This)
}
func (g *Graph) Number() interface{} {
	return number(g.Interface())
}
func (g *Graph) ThisNumber() interface{} {
	return number(g.This)
}
func (g *Graph) ThisInt64() (int64, bool) {
	return _int64f(g.This)
}
func (g *Graph) ThisFloat64() (float64, bool) {
	return _float64f(g.This)
}
func (g *Graph) Scalar() interface{} {
	itf := g.Interface()
	if itf == nil && g.Out != nil {
		itf = g.Out[0].This
	}
	n := number(itf)
	if n != nil {
		return n
	}
	b, ok := _boolf(itf)
	if ok {
		return b
	}
	return itf
}
func (g *Graph) ThisScalar() interface{} {
	itf := g.This
	if itf == nil && g.Out != nil {
		itf = g.Out[0].This
	}
	n := number(itf)
	if n != nil {
		return n
	}
	b, ok := _boolf(itf)
	if ok {
		return b
	}
	return itf
}
func (g *Graph) Interface() interface{} {
	if g.Out != nil && len(g.Out) != 0 {
		return g.Out[0].This
	}
	return nil
}
func number(itf interface{}) interface{} {
	if itf == nil {
		return nil
	}
	f, ok := _float64(itf)
	if ok {
		return f
	}
	i, ok := _int64(itf)
	if ok {
		return i
	}
	s := _string(itf)
	if len(s) == 0 {
		return nil
	}
	if isInteger(s) {
		n, err := strconv.ParseInt(s, 10, 64)
		if err != nil {
			return nil
		}
		return n
	}
	n, err := strconv.ParseFloat(s, 64)
	if err != nil {
		return nil
	}
	return n
}
func (g *Graph) GetString(path string) (string, error) {
	if len(path) == 0 {
		return g.String(), nil
	}
	i := g.Get(path)
	if i == nil {
		return "", errors.New("not found")
	}
	if i.Len() == 0 {
		return "", errors.New("Get() design error: not subnodes")
	}
	return _string(i.Out[0].This), nil
}
func (g *Graph) GetBytes(path string) ([]byte, error) {
	if len(path) == 0 {
		return g.Bytes(), nil
	}
	i := g.Get(path)
	if i == nil {
		return nil, errors.New("not found")
	}
	if i.Len() == 0 {
		return nil, errors.New("Get() design error: not subnodes")
	}
	return _bytes(i.Out[0].This), nil
}
func (g *Graph) GetInt64(path string) (int64, error) {
	if len(path) == 0 {
		return g.Int64(), nil
	}
	i := g.Get(path)
	if i == nil {
		return 0, errors.New("not found")
	}
	if i.Len() == 0 {
		return 0, errors.New("Get() design error: not subnodes")
	}
	j, ok := _int64f(i.Out[0].This)
	if !ok {
		return 0, errors.New("incompatible type")
	}
	return j, nil
}
func (g *Graph) GetFloat64(path string) (float64, error) {
	if len(path) == 0 {
		return g.Float64(), nil
	}
	i := g.Get(path)
	if i == nil {
		return 0, errors.New("not found")
	}
	if i.Len() == 0 {
		return 0, errors.New("Get() design error: not subnodes")
	}
	j, ok := _float64f(i.Out[0].This)
	if !ok {
		return 0, errors.New("not a number")
	}
	return j, nil
}