*string to nil if empty string about mold HOT 9 CLOSED

v.Set(reflect.Zero(parent.Type()))

func (t *Transformer) setByField(ctx context.Context, orig reflect.Value, ct *cTag) (err error) {
	current, kind := extractType(orig)

	if ct != nil && ct.hasTag {
		for ct != nil {
			switch ct.typeof {
			case typeEndKeys:
				return
			case typeDive:
				ct = ct.next

				switch kind {
				case reflect.Slice, reflect.Array:
					err = t.setByIterable(ctx, current, ct)
				case reflect.Map:
					err = t.setByMap(ctx, current, ct)
				default:
					err = ErrInvalidDive
				}
				return

			default:
				if !current.CanAddr() {
					newVal := reflect.New(current.Type()).Elem()
					newVal.Set(current)
					if err = ct.fn(ctx, t, newVal, ct.param); err != nil {
						return
					}
					orig.Set(newVal)
				} else {
					if err = ct.fn(ctx, t, current, ct.param); err != nil {
						return
					}
				}
				ct = ct.next
			}
		}
	}

package main

import (
	"context"
	"fmt"
	"log"
	"reflect"

	"github.com/go-playground/mold/v4"
)

var tform *mold.Transformer

func main() {
	tform = mold.New()
	tform.Register("nilEmptyString", nilEmptyString)

	type Test struct {
		String *string `mold:"nilEmptyString"`
	}

	myEmptyString := ""
	tt := Test{String: &myEmptyString}

	err := tform.Struct(context.Background(), &tt)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("RESULT: %#v %t\n", tt, tt.String == nil)
}

func nilEmptyString(_ context.Context, fl mold.FieldLevel) error {
	fl.Parent().Set(reflect.Zero(fl.Parent().Type()))
	return nil
}

package main

import (
	"context"
	"fmt"
	"log"
	"reflect"

	"github.com/go-playground/mold/v3"
)

var tform *mold.Transformer

func main() {
	tform = mold.New()
	tform.Register("nilEmptyString", nilEmptyString)

	type Test struct {
		String *string `mold:"nilEmptyString"`
	}

	myEmptyString := ""
	tt := Test{String: &myEmptyString}

	err := tform.Struct(context.Background(), &tt)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", tt)

	var myString string
	err = tform.Field(context.Background(), &myString, "nilEmptyString")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(myString)
}

func nilEmptyString(_ context.Context, _ *mold.Transformer, v reflect.Value, _ string) error {
	s, ok := v.Interface().(*string)
	if !ok { // ok is always false, why?
		return nil
	}

	if s != nil && *s != "" {
		return nil
	}

	if s != nil && *s == "" {
		v.SetPointer(nil)
	}

	// v.Set(nil) // how to do this?

	return nil
}