partialField dandole mayor responsabilidad al hacerlo generico

A/main.go

@@ -29,12 +29,22 @@ func main() {
 
 
 
-	doInt := aflds.NewDFieldInt("Mi",func()int{ return randomInt(1, 100000) })
-
+	doInt := *aflds.NewDOFieldInt("Mi",func()int{ return randomInt(1, 100000) })
+	doInt2 := doInt
+
+	v := doInt.Native()
+	v1 := doInt2.Native()
+	fmt.Printf("Kind %s\n",doInt.Kind().Name())
+	fmt.Printf("Valor %d\n",v)
+	for i:=0; i<100000; i++ {
+		v1 = doInt2.Native()
+		if v != v1 {
+			fmt.Println("ERROR ES DIFE>RENTE")
+			break
+		}
+	}
+	fmt.Printf("Valor %d\n",v1)
 
-	 fmt.Printf("1 - %v\n",doInt.Value())
-	 fmt.Printf("2 - %v\n",doInt.Value())
-	 fmt.Printf("3 - %v\n",doInt.Value())
 
 
 }

AATest/field_benchmarks_test.go

@@ -64,3 +64,44 @@ func BenchmarkAfldsAcc (b *testing.B) {
 		}
 	}
 }
+
+
+func BenchmarkAfldsAcDf (b *testing.B) {
+	var d[8]any
+	flds := []aflds.Field {
+		aflds.NewDFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDFieldInt("d1",func()int{ return -3 }),
+	}
+	for i := 0; i < b.N; i++ {
+		for i:=0; i<8; i++ {
+			d[i]=flds[i].Value()
+		}
+	}
+}
+
+
+
+func BenchmarkAfldsAcDo (b *testing.B) {
+	var d[8]any
+	flds := []aflds.Field {
+		aflds.NewDOFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDOFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDOFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDOFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDOFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDOFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDOFieldInt("d1",func()int{ return -3 }),
+		aflds.NewDOFieldInt("d1",func()int{ return -3 }),
+	}
+	for i := 0; i < b.N; i++ {
+		for i:=0; i<8; i++ {
+			d[i]=flds[i].Value()
+		}
+	}
+}

core/ablds/buildable.go

@@ -28,6 +28,8 @@ package ablds
 
 type (
 
+	// Buildable define un contrato para objetos que pueden construirse utilizando un Builder.
+	// Se espera que estos objetos implementen un método Build que tome una instancia de Builder.
 	Buildable 	interface {
 
 		Build (builder Builder)

core/ablds/builder.go

@@ -27,6 +27,7 @@ package ablds
 
 type (
 
+	// Builder es la interfaz base para todos los tipos de builder,  hereda de la interfaz ValueBuilder
 	Builder interface {
 		ValueBuilder
 	}

core/ablds/list_builder.go

@@ -26,7 +26,7 @@ package ablds
 
 
 type (
-
+	// ListBuilder es una interfaz que define el método Item para construir listas.
 	ListBuilder interface {
 
 		Item () Builder

core/ablds/map_builder.go

@@ -26,6 +26,7 @@ package ablds
 
 type (
 
+	// MapBuilder es una interfaz que define el método Element para construir mapas.
 	MapBuilder 	interface {
 		Element (key any) Builder
 	}

core/ablds/object_builder.go

@@ -27,6 +27,7 @@ package ablds
 
 type (
 
+	// ObjectBuilder es una interfaz que define el método Field para construir objetos.
 	ObjectBuilder 	interface {
 		Field (name string) Builder
 	}

core/ablds/readme.md

@@ -0,0 +1,51 @@
+<h1><span style="color:red; font-style:italic">Go Framework Project ACTIVE</span></h1>
+
+### Active Thing · [activething.com](https://activething.com)
+Source [git.activething.com/go]
+Autor [Juan V. Navarro](juanvnl@activething.com)
+
+---
+
+# ablds (ActiveBuiLDerS)
+
+ablds es una librería de Go diseñada para facilitar la creación eficiente y rápida de serializaciones o formatos de objetos, mapas, listas, y otros tipos de datos comunes en Go. Su propósito principal es proporcionar una alternativa eficiente a la reflexión en Go, que puede tener un coste de ejecución considerable.
+
+## ¿Qué hace ablds?
+
+**ablds** proporciona una serie de interfaces y tipos que permiten construir y manipular estructuras de datos de forma modular y flexible, evitando así el uso de reflexión. Estas estructuras de datos pueden ser luego serializadas en diferentes formatos, como JSON, XML, o cualquier otro formato personalizado, según las necesidades del usuario.
+
+## ¿Cómo funciona?
+
+La librería se basa en dos conceptos principales: los **Builders** y los **Buildables**.
+
+- **Builders**: Son interfaces que definen métodos para construir diferentes tipos de estructuras de datos. Por ejemplo, tenemos builders para listas, mapas, y objetos.
+- **Buildables**: Son interfaces que representan los diferentes tipos de datos que pueden ser construidos utilizando los builders. Estos tipos pueden incluir cualquier cosa, desde valores simples como strings o números hasta estructuras de datos más complejas.
+
+**ablds** ofrece una serie de métodos para cada tipo de builder, lo que permite agregar y configurar los datos de manera incremental y modular. Esto hace que la construcción de estructuras de datos sea más flexible y fácil de manejar, especialmente en casos donde se necesita construir objetos complejos con múltiples niveles de anidamiento.
+
+## Ejemplo de Uso
+
+```go
+// Crear un objeto ablds
+builder := NewObjectBuilder()
+
+// Agregar campos al objeto
+builder.Field("name").String("John Doe")
+builder.Field("age").Int(30)
+builder.Field("is_active").Bool(true)
+
+// Construir el objeto
+obj := builder.Build()
+
+// Serializar el objeto a JSON
+jsonBytes, _ := json.Marshal(obj)
+fmt.Println(string(jsonBytes))
+
+
+***
+
+Copyright 2024 [activething.com]
+
+
+[activething.com]: <https://activething.com>
+[git.activething.com/go]:<https://git.activething.com/go>

core/ablds/value_builder.go

@@ -31,6 +31,7 @@ import (
 
 type (
 
+	// ValueBuilder define métodos para construir diferentes tipos de datos dentro de un valor estructurado.
 	ValueBuilder interface {
 		Buildable (value Buildable)
 

core/aflds/active.go

@@ -32,7 +32,11 @@ import (
 
 const(
 
-	kindBits = 16
+	kindBits = 12
+)
+
+const(
+	kindNameSep = "."
 )
 
 
@@ -58,16 +62,21 @@ var (
 	}
 
 	g = struct {
-		timeZero 	time.Time
-		reflectZero reflect.Value
+		timeZero 	  time.Time
+		reflectZero   reflect.Value
 
-		kindNames 	[]string
+		kindNames 	  []string
+		kindDeferName string
+		kindOnceName  string
 
 		/* 🚫 DEPRECATED
 		constructors map[reflect.Type]func(name string, valueFn any) Field
 		*/
 
 	}{
+		kindDeferName : "defer",
+		kindOnceName  : "defer_once",
+
 		kindNames   : []string{
 			"any",
 			"bool",
@@ -80,10 +89,6 @@ var (
 			"duration",
 			"error",
 			"reflect",
-			"",
-			"",
-			"",
-			"defer",
 		},
 
 		/* 🚫 DEPRECATED : Tiene mejor rendimiento con el type switch, se descarta

core/aflds/factory.go

@@ -44,6 +44,43 @@ func Create (name string, value any, kind Kind) Field {
 	if kind == 0 {
 		return CreateFromValue(name,value)
 	}
+	if kind.IsDefer() {
+		switch kind {
+		case KindDefer,
+	 		 KindAny 		: return NewDFieldAny		(name, value.(func() any))
+		case KindBool		: return NewDFieldBool		(name, value.(func() bool))
+		case KindString		: return NewDFieldString	(name, value.(func() string))
+		case KindBinary		: return NewDFieldBinary	(name, value.(func() []byte))
+		case KindInt		: return NewDFieldInt		(name, value.(func() int))
+		case KindUint		: return NewDFieldUint		(name, value.(func() uint))
+		case KindFloat		: return NewDFieldFloat		(name, value.(func() float64))
+		case KindTime		: return NewDFieldTime		(name, value.(func() time.Time))
+		case KindDuration	: return NewDFieldDuration	(name, value.(func() time.Duration))
+		case KindError		: return NewDFieldError		(name, value.(func() error))
+		case KindReflect	: return NewDFieldReflect	(name, value.(func() reflect.Value))
+		default: panic(G.ErrInvalidKind)
+		}
+	}
+
+	if kind.IsDeferOnce() {
+		switch kind {
+		case KindDeferOnce,
+			 KindAny		: 	return NewDOFieldAny		(name, value.(func() any))
+		case KindBool		:	return NewDOFieldBool		(name, value.(func() bool))
+		case KindString		: return NewDOFieldString	(name, value.(func() string))
+		case KindBinary		:return NewDOFieldBinary	(name, value.(func() []byte))
+		case KindInt		:	return NewDOFieldInt		(name, value.(func() int))
+		case KindUint		:	return NewDOFieldUint		(name, value.(func() uint))
+		case KindFloat		:	return NewDOFieldFloat		(name, value.(func() float64))
+		case KindTime		:	return NewDOFieldTime		(name, value.(func() time.Time))
+		case KindDuration	: return NewDOFieldDuration	(name, value.(func() time.Duration))
+		case KindError		: return NewDOFieldError		(name, value.(func() error))
+		case KindReflect	: 	return NewDOFieldReflect	(name, value.(func() reflect.Value))
+		default:
+			panic(G.ErrInvalidKind)
+		}
+	}
+
 	switch kind {
 	case KindAny 	 : return NewFieldAny   (name,value)
 	case KindBool  	 : return NewFieldBool  (name,value.(bool))
@@ -56,21 +93,6 @@ func Create (name string, value any, kind Kind) Field {
 	case KindDuration:return NewFieldDuration(name,value.(time.Duration))
 	case KindError	 : return NewFieldError (name,value.(error))
 	case KindReflect : return NewFieldReflect(name,value.(reflect.Value))
-
-	//valuerKind Fields
-	case KindDefer,
-		 KindDeferAny	  : return NewDFieldAny   (name,value.(func()any))
-	case KindDeferBool	  : return NewDFieldBool  (name,value.(func()bool))
-	case KindDeferString  : return NewDFieldString(name,value.(func()string))
-	case KindDeferBinary  : return NewDFieldBinary(name,value.(func()[]byte))
-	case KindDeferInt	  : return NewDFieldInt   (name,value.(func()int))
-	case KindDeferUint	  : return NewDFieldUint  (name,value.(func()uint))
-	case KindDeferFloat	  : return NewDFieldFloat (name,value.(func()float64))
-	case KindDeferTime	  : return NewDFieldTime  (name,value.(func()time.Time))
-	case KindDeferDuration:return NewDFieldDuration (name,value.(func()time.Duration))
-	case KindDeferError   : return NewDFieldError (name,value.(func()error))
-	case KindDeferReflect :return NewDFieldReflect(name,value.(func()reflect.Value))
-
 	default:
 		panic(G.ErrInvalidKind)
 	}

core/aflds/field.go

@@ -28,7 +28,7 @@ import "ablds"
 type (
 
 	Field interface {
-		NativeResolver
+		typeResolver
 
 		Kind () Kind
 		Name () string

core/aflds/field_any.go

@@ -32,46 +32,43 @@ import (
 type (
 	
 	FieldAny	struct {
-		valuer[any]
-		partialField
+		partialField[any]
 	}
 )
 
 
 func NewFieldAny (name string, value any) *FieldAny {
-	return &FieldAny{
-		valuer: newLocalValuer[any](value),
-		partialField :  makePartialField(name) } }
+	return &FieldAny{ partialField : makePartialFieldLocal[any](name,value) } }
 
 
-func NewDFieldAny (name string, valueFn func() any) *FieldAny {
-	return &FieldAny{
-		valuer: newDeferValuer[any](valueFn),
-		partialField: makePartialField(name) } }
+func NewDFieldAny(name string, valueFn func() any) *FieldAny {
+	return &FieldAny{ partialField : makePartialFieldDefer[any](name,valueFn) } }
+
+func NewDOFieldAny (name string, valueFn func()any) *FieldAny {
+	return &FieldAny{ partialField : makePartialFieldOnce[any](name,valueFn) }}
 
 
 func (f FieldAny) Kind() Kind {
 	return KindAny | f.valuerKind() }
 
 
-
 func (f FieldAny) Bool   () (bool,bool) {
-	v,ok := f.native().(bool)
+	v,ok := f.Native().(bool)
 	return v,ok
 }
 
 func (f FieldAny) Binary () ([]byte,bool) {
-	v, ok := f.native().([]byte)
+	v, ok := f.Native().([]byte)
 	return v, ok
 }
 
 func (f FieldAny) String () (string,bool) {
-	v,ok := f.native().(string)
+	v,ok := f.Native().(string)
 	return v,ok
 }
 
 func (f FieldAny) Int () (int,bool) {
-	switch t := f.native().(type) {
+	switch t := f.Native().(type) {
 	case int  : return t,true
 	case int8 : return int(t),true
 	case int16: return int(t),true
@@ -82,7 +79,7 @@ func (f FieldAny) Int () (int,bool) {
 }
 
 func (f FieldAny) Uint () (uint,bool) {
-	switch t := f.native().(type) {
+	switch t := f.Native().(type) {
 	case uint  : return t,true
 	case uint8 : return uint(t),true
 	case uint16: return uint(t),true
@@ -93,7 +90,7 @@ func (f FieldAny) Uint () (uint,bool) {
 }
 
 func (f FieldAny) Float () (float64,bool) {
-	vl := f.native()
+	vl := f.Native()
 	v, ok := vl.(float64)
 	if !ok {
 		var f32 float32
@@ -106,32 +103,39 @@ func (f FieldAny) Float () (float64,bool) {
 
 
 func (f FieldAny) Date () (time.Time,bool) {
-	v, ok := f.native().(time.Time)
+	v, ok := f.Native().(time.Time)
 	return v, ok
 }
 
 func (f FieldAny) Time () (time.Time,bool) {
-	v, ok := f.native().(time.Time)
+	v, ok := f.Native().(time.Time)
+	return v, ok
+}
+
+func (f FieldAny) Duration () (time.Duration,bool) {
+	v, ok := f.Native().(time.Duration)
 	return v, ok
 }
 
 
+
 func (f FieldAny) Error () (error,bool) {
-	v, ok := f.native().(error)
+	v, ok := f.Native().(error)
 	return v, ok
 }
 
 
 func (f FieldAny) Reflect () (reflect.Value,bool) {
-	v, ok := f.native().(reflect.Value)
+	v, ok := f.Native().(reflect.Value)
 	return v, ok
 }
 
 
-
 func (f FieldAny) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Any(f.native()) }) }
+		b.Field(f.name).Any(f.Native())
+}) }
+
 
 
 

core/aflds/field_binary.go

@@ -28,22 +28,19 @@ import "ablds"
 type (
 
 	FieldBinary struct {
-		valuer [[]byte]
-		partialField
+
+		partialField[[]byte]
 	}
 )
 
 func NewFieldBinary (name string, value []byte) *FieldBinary {
-	return &FieldBinary{
-		valuer: newLocalValuer[[]byte](value),
-		partialField: makePartialField(name) }}
-
+	return &FieldBinary{ partialField : makePartialFieldLocal[[]byte](name,value) } }
 
 func NewDFieldBinary (name string, valueFn func() []byte) *FieldBinary {
-	return &FieldBinary {
-		valuer : newDeferValuer[[]byte](valueFn),
-		partialField: makePartialField(name) } }
+	return &FieldBinary{ partialField : makePartialFieldDefer[[]byte](name,valueFn) } }
 
+func NewDOFieldBinary (name string, valueFn func() []byte) *FieldBinary {
+	return &FieldBinary{ partialField : makePartialFieldOnce[[]byte](name,valueFn) } }
 
 
 func (f FieldBinary) Kind () Kind {
@@ -51,9 +48,12 @@ func (f FieldBinary) Kind () Kind {
 
 
 func (f FieldBinary) Binary() ([]byte,bool) {
-	return f.native(),true }
+	return f.Native(),true }
+
 
 
 func (f FieldBinary) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Binary(f.native()) }) }
+		b.Field(f.name).Binary(f.Native())	}) }
+
+

core/aflds/field_bool.go

@@ -28,21 +28,19 @@ import "ablds"
 type (
 
 	FieldBool 	struct {
-		valuer[bool]
-		partialField
+		
+		partialField[bool]
 	}
 )
 
 func NewFieldBool (name string, value bool) *FieldBool {
-	return &FieldBool{
-		valuer : newLocalValuer[bool](value),
-		partialField: makePartialField(name) } }
-
+	return &FieldBool{ partialField:  makePartialFieldLocal[bool](name,value)  } }
 
 func NewDFieldBool (name string, valueFn func() bool) *FieldBool {
-	return &FieldBool{
-		valuer : newDeferValuer[bool](valueFn),
-		partialField:    makePartialField(name) } }
+	return &FieldBool{ partialField: makePartialFieldDefer[bool](name,valueFn) } }
+
+func NewDOFieldBool (name string, valueFn func() bool) *FieldBool {
+	return &FieldBool{ partialField: makePartialFieldOnce[bool](name,valueFn) } }
 
 
 
@@ -50,11 +48,10 @@ func (f FieldBool) Kind () Kind {
 	return KindBool | f.valuerKind() }
 
 
-
 func (f FieldBool) Bool() (bool,bool) {
-	return f.native(),true }
+	return f.Native(),true }
 
 
 func (f FieldBool) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Bool(f.native()) }) }
+		b.Field(f.name).Bool(f.Native())	}) }

core/aflds/field_duration.go

@@ -31,21 +31,19 @@ import (
 type (
 
 	FieldDuration 	struct {
-		valuer[time.Duration]
-		partialField
+		
+		partialField [time.Duration]
 	}
 )
 
 func NewFieldDuration (name string, value time.Duration) *FieldDuration {
-	return &FieldDuration{
-		valuer : newLocalValuer[time.Duration](value),
-		partialField: makePartialField(name) } }
-
+	return &FieldDuration{ partialField : makePartialFieldLocal[time.Duration](name,value) } }
 
 func NewDFieldDuration (name string, valueFn func() time.Duration) *FieldDuration {
-	return &FieldDuration{
-		valuer : newDeferValuer[time.Duration](valueFn),
-		partialField:    makePartialField(name) } }
+	return &FieldDuration{ partialField : makePartialFieldDefer[time.Duration](name,valueFn) } }
+
+func NewDOFieldDuration (name string, valueFn func() time.Duration) *FieldDuration {
+	return &FieldDuration{ partialField : makePartialFieldOnce[time.Duration](name,valueFn) } }
 
 
 
@@ -54,9 +52,9 @@ func (f FieldDuration) Kind () Kind {
 
 
 func (f FieldDuration) Duration() (time.Duration,bool) {
-	return f.native(),true }
+	return f.Native(),true }
 
 
 func (f FieldDuration) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Duration(f.native()) }) }
+		b.Field(f.name).Duration(f.Native()) }) }

core/aflds/field_error.go

@@ -23,29 +23,25 @@
 
 package aflds
 
-import (
-	"ablds"
-)
+import "ablds"
 
 type (
 
 	FieldError 	struct {
-		valuer[error]
-		partialField
+		
+		partialField[error]
 	}
 )
 
 
 func NewFieldError (name string, value error) *FieldError {
-	return &FieldError{
-		valuer: newLocalValuer[error](value),
-		partialField: makePartialField(name) }}
-
+	return &FieldError{ partialField : makePartialFieldLocal[error](name,value) }}
 
 func NewDFieldError (name string, valueFn func() error) *FieldError {
-	return &FieldError{
-		valuer: newDeferValuer[error](valueFn),
-		partialField:    makePartialField(name) } }
+	return &FieldError{ partialField : makePartialFieldDefer[error](name,valueFn) } }
+
+func NewDOFieldError (name string, valueFn func() error) *FieldError {
+	return &FieldError{ partialField : makePartialFieldOnce[error](name,valueFn) } }
 
 
 func (f FieldError) Kind () Kind {
@@ -53,9 +49,10 @@ func (f FieldError) Kind () Kind {
 
 
 func (f FieldError) Error() (error,bool) {
-	return f.native(),true }
+	return f.Native(),true }
+
 
 
 func (f FieldError) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Error(f.native()) }) }
+		b.Field(f.name).Error(f.Native())	}) }

core/aflds/field_float.go

@@ -28,28 +28,19 @@ import "ablds"
 type (
 
 	FieldFloat 	struct {
-		valuer[float64]
-		partialField
-		value 	*float64
-		valueFn func() float64
+
+		partialField[float64]
 	}
 )
 
 func NewFieldFloat (name string, value float64) *FieldFloat {
-	return &FieldFloat{
-		valuer: newLocalValuer[float64](value),
-		partialField: makePartialField(name)  } }
-
+	return &FieldFloat{ partialField : makePartialFieldLocal[float64](name,value)  } }
 
 func NewDFieldFloat (name string, valueFn func()float64) *FieldFloat {
-	if valueFn == nil {
-		panic(G.ErrInvalidDeferFunc)
-	}
-	return &FieldFloat{
-		valuer : newDeferValuer[float64](valueFn),
-		partialField:    makePartialField(name) } }
-
+	return &FieldFloat{ partialField : makePartialFieldDefer[float64](name,valueFn) } }
 
+func NewDOFieldFloat (name string, valueFn func()float64) *FieldFloat {
+	return &FieldFloat{ partialField : makePartialFieldOnce[float64](name,valueFn) } }
 
 
 func (f FieldFloat) Kind () Kind {
@@ -57,11 +48,10 @@ func (f FieldFloat) Kind () Kind {
 
 
 func (f FieldFloat) Float() (float64,bool) {
-	return f.valueFn(),true }
+	return f.Native(),true }
+
 
 
 func (f FieldFloat) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Float64(f.native())
-	})
-}
+		b.Field(f.name).Float64(f.Native())	}) }

core/aflds/field_int.go

@@ -23,34 +23,24 @@
 
 package aflds
 
-import (
-	"ablds"
-)
+import "ablds"
 
 type (
 
 	FieldInt struct {
-		valuer [int]
-		partialField
-
+		partialField[int]
 	}
 )
 
-func NewFieldInt (name string, value int) *FieldInt {
-	return &FieldInt{
-		partialField: makePartialField(name,),
-		valuer      : newLocalValuer[int](value)  } }
 
+func NewFieldInt (name string, value int) *FieldInt {
+	return &FieldInt{ partialField : makePartialFieldLocal[int](name,value) }}
 
 func NewDFieldInt (name string, valueFn func()int) *FieldInt {
-	if valueFn == nil {
-		panic(G.ErrInvalidDeferFunc)
-	}
-	return &FieldInt{
-		partialField: makePartialField(name),
-		valuer		: newDeferValuer[int](valueFn) } }
-
+	return &FieldInt{ partialField : makePartialFieldDefer[int](name,valueFn) }}
 
+func NewDOFieldInt (name string, valueFn func()int) *FieldInt {
+	return &FieldInt{ partialField : makePartialFieldOnce[int](name,valueFn) }}
 
 
 
@@ -59,11 +49,16 @@ func (f FieldInt) Kind () Kind {
 
 
 func (f FieldInt) Int() (int,bool) {
-	return f.native(),true }
-
+	return f.Native(),true }
 
 
 func (f FieldInt) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Int(f.native()) }) }
+		b.Field(f.name).Int(f.Native())	}) }
+
+
+
+
+
+
 

core/aflds/field_reflect.go

@@ -31,21 +31,19 @@ import (
 type (
 
 	FieldReflect 	struct {
-		valuer[reflect.Value]
-		partialField
+		
+		partialField[reflect.Value]
 	}
 )
 
 func NewFieldReflect (name string, value reflect.Value) *FieldReflect {
-	return &FieldReflect{
-		valuer : newLocalValuer[reflect.Value](value),
-		partialField:  makePartialField(name) } }
-
+	return &FieldReflect{ partialField : makePartialFieldLocal[reflect.Value](name,value)  } }
 
 func NewDFieldReflect (name string, valueFn func()reflect.Value) *FieldReflect {
-	return &FieldReflect{
-		valuer: newDeferValuer[reflect.Value](valueFn),
-		partialField:    makePartialField(name )} }
+	return &FieldReflect{ partialField : makePartialFieldDefer[reflect.Value](name,valueFn) } }
+
+func NewDOFieldReflect (name string, valueFn func()reflect.Value) *FieldReflect {
+	return &FieldReflect{ partialField : makePartialFieldOnce[reflect.Value](name,valueFn) } }
 
 
 func (f FieldReflect) Kind () Kind {
@@ -53,10 +51,10 @@ func (f FieldReflect) Kind () Kind {
 
 
 func (f FieldReflect) Reflect() (reflect.Value,bool) {
-	return f.native(),true }
+	return f.Native(),true }
 
 
 
 func (f FieldReflect) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Reflect(f.native()) }) }
+		b.Field(f.name).Reflect(f.Native()) }) }

core/aflds/field_strings.go

@@ -23,42 +23,36 @@
 
 package aflds
 
-import (
-	"ablds"
-)
+import "ablds"
 
 type (
 
 	FieldString struct {
-		valuer[string]
-		partialField
+		
+		partialField[string]
 	}
 )
 
-func NewFieldString (name string, value string) *FieldString {
-	return &FieldString{
-		valuer : newLocalValuer[string](value),
-		partialField: makePartialField(name) } }
 
+func NewFieldString (name string, value string) *FieldString {
+	return &FieldString{ partialField : makePartialFieldLocal[string](name,value)  } }
 
-func NewDFieldString (name string, valueFn func()string) *FieldString {
-	return &FieldString{
-		valuer : newDeferValuer[string](valueFn) ,
-		partialField:    makePartialField(name) } }
+func NewDFieldString (name string, valueFn func() string) *FieldString {
+	return &FieldString{ partialField : makePartialFieldDefer[string](name,valueFn) } }
 
+func NewDOFieldString (name string, valueFn func() string) *FieldString {
+	return &FieldString{ partialField : makePartialFieldOnce[string](name,valueFn) } }
 
 
 func (f FieldString) Kind () Kind {
 	return KindString | f.valuerKind() }
 
-
 func (f FieldString) String() (string,bool) {
-	return f.native(),true }
+	return f.Native(),true }
 
 
 func (f FieldString) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).String(f.native())
-	})
-}
+		b.Field(f.name).String(f.Native())	}) }
+
 

core/aflds/field_time.go

@@ -31,22 +31,20 @@ import (
 type (
 
 	FieldTime 	struct {
-		valuer[time.Time]
-		partialField
+		
+		partialField[time.Time]
 	}
 )
 
-func NewFieldTime (name string, value time.Time) *FieldTime {
-	return &FieldTime{
-		valuer : newLocalValuer[time.Time](value),
-		partialField: makePartialField(name) } }
 
+func NewFieldTime (name string, value time.Time) *FieldTime {
+	return &FieldTime{ partialField : makePartialFieldLocal[time.Time](name,value) } }
 
 func NewDFieldTime (name string, valueFn func() time.Time) *FieldTime {
-	return &FieldTime{
-		valuer : newDeferValuer[time.Time](valueFn),
-		partialField:    makePartialField(name) } }
+	return &FieldTime{ partialField : makePartialFieldDefer[time.Time](name,valueFn) } }
 
+func NewDOFieldTime (name string, valueFn func() time.Time) *FieldTime {
+	return &FieldTime{ partialField : makePartialFieldOnce[time.Time](name,valueFn) } }
 
 
 func (f FieldTime) Kind () Kind {
@@ -54,9 +52,9 @@ func (f FieldTime) Kind () Kind {
 
 
 func (f FieldTime) Time() (time.Time,bool) {
-	return f.native(),true }
+	return f.Native(),true }
 
 
 func (f FieldTime) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Time(f.native()) }) }
+		b.Field(f.name).Time(f.Native()) }) }

core/aflds/field_uint.go

@@ -23,32 +23,24 @@
 
 package aflds
 
-import (
-	"ablds"
-)
+import "ablds"
 
 type (
 
 	FieldUint struct {
-		valuer [uint]
-		partialField
-
+		
+		partialField[uint]
 	}
 )
 
 func NewFieldUint (name string, value uint) *FieldUint {
-	return &FieldUint{
-		partialField: makePartialField(name),
-		valuer      : newLocalValuer[uint](value)  } }
+	return &FieldUint{ partialField : makePartialFieldLocal[uint](name,value) }}
 
+func NewDFieldUint (name string, valueFn func() uint) *FieldUint {
+	return &FieldUint{ partialField : makePartialFieldDefer[uint](name,valueFn) }}
 
-func NewDFieldUint (name string, valueFn func()uint) *FieldUint {
-	if valueFn == nil {
-		panic(G.ErrInvalidDeferFunc)
-	}
-	return &FieldUint{
-		partialField: makePartialField(name),
-		valuer		: newDeferValuer[uint](valueFn) } }
+func NewDOFieldUint (name string, valueFn func() uint) *FieldUint {
+	return &FieldUint{ partialField : makePartialFieldOnce[uint](name,valueFn) }}
 
 
 
@@ -59,11 +51,10 @@ func (f FieldUint) Kind () Kind {
 
 
 func (f FieldUint) Uint() (uint,bool) {
-	return f.native(),true }
+	return f.Native(),true }
 
 
 
 func (f FieldUint) Build (builder ablds.Builder) {
 	builder.Object(func(b ablds.ObjectBuilder){
-		b.Field(f.name).Uint(f.native()) }) }
-
+		b.Field(f.name).Uint(f.Native())	}) }

core/aflds/fields.go

@@ -34,6 +34,7 @@ type (
 	// para gestionar y manipular dicha lista.
 	Fields []Field
 
+
 )
 
 
@@ -62,18 +63,23 @@ func (f Fields) Get(name string) Field {
 
 
 func (f Fields) GetAll (name string) []Field {
-	var ls []Field
+	return f.Filter(func(fl Field) bool {
+		return fl.Name() == name
+	})
+}
+
+
+func (f Fields) Filter (filter func(field Field) bool ) Fields {
+	var ls Fields
 	for _,fl := range f {
-		if fl.Name() == name {
-			ls = append(ls,fl)
+		if filter(fl) {
+			ls = append(ls, fl)
 		}
 	}
 	return ls
 }
 
 
-
-
 func (f Fields) Add(field Field) Fields {
 	if field != nil {
 		return append(f,field)

core/aflds/kind.go

@@ -39,26 +39,13 @@ const(
 	KindError
 	KindReflect
 
-	KindOnce  Kind = 8192
-	KindDefer Kind = 16384
+	KindDefer  		Kind = 8192
+	KindDeferOnce	Kind = 16384
 
+	typesMask  Kind = 0b0000011111111111
 )
 
-const(
-
-	KindDeferAny 			= KindDefer|KindAny
-	KindDeferBool 		= KindDefer|KindBool
-	KindDeferString		= KindDefer|KindString
-	KindDeferBinary		= KindDefer|KindBinary
-	KindDeferInt 			= KindDefer|KindInt
-	KindDeferUint 		= KindDefer|KindUint
-	KindDeferFloat		= KindDefer|KindFloat
-	KindDeferTime 		= KindDefer|KindTime
-	KindDeferDuration		= KindDefer|KindDuration
-	KindDeferError 		= KindDefer|KindError
-	KindDeferReflect  	= KindDefer|KindReflect
 
-)
 
 
 type (
@@ -104,12 +91,36 @@ func (k Kind) IsReflect() bool {
 func (k Kind) IsDefer() bool {
 	return k&KindDefer != 0 }
 
+func (k Kind) IsDeferOnce () bool {
+	return k&KindDeferOnce  != 0
+}
+
+func (k Kind) Name () string {
+	c := Kind(1)
+	nm:= ""
+	for i := 0; i<kindBits; i++ {
+		c = 1 << i
+		if c&k != 0 {
+			nm = g.kindNames[i]
+			if k.IsDefer() {
+				nm += kindNameSep + g.kindDeferName
+				return nm
+			}
+			if k.IsDeferOnce() {
+				nm += kindNameSep + g.kindOnceName
+			}
+			return nm
+		}
+	}
+	return ""
+}
+
 
 
-func (k Kind) Count () int {
+func (k Kind) count() int {
 	return bits.OnesCount16(uint16(k)) }
 
-func (k Kind) Kinds () []Kind {
+func (k Kind) kinds() []Kind {
 	if k == 0 {
 		return nil
 	}
@@ -124,7 +135,7 @@ func (k Kind) Kinds () []Kind {
 	return ls
 }
 
-func (k Kind) KindNames () []string {
+func (k Kind) kindNames() []string {
 	if k==0 {
 		return []string{""}
 	}
@@ -136,6 +147,12 @@ func (k Kind) KindNames () []string {
 			ls = append(ls, g.kindNames[i])
 		}
 	}
+	if k.IsDeferOnce() {
+		ls = append(ls, g.kindOnceName)
+	}
+	if k.IsDefer() {
+		ls = append(ls, g.kindDeferName)
+	}
 	return ls
 }
 

core/aflds/partial_field.go

@@ -32,7 +32,7 @@ type (
 
 
 	// partialField representa un Field parcialmente definido con solo el nombre.
-	// Implementa el interface NativeResolver de forma nula para proporcionar valores
+	// Implementa el interface typeResolver de forma nula para proporcionar valores
 	// predeterminados para los tipos de datos comunes. Cuando un objeto Field
 	// sobrescribe alguno de estos métodos, se produce shadowing, lo que significa
 	// que la implementación en Field prevalecerá sobre la implementación nula de
@@ -44,36 +44,42 @@ type (
 )
 
 
-func makePartialField[T any] (name string) partialField[T] {
-	return partialField[T]{
-		name : name } }
-
-
-func (f partialField[T]) Name() string {
-	return f.name }
-
-
-func (f partialField[T]) Bool	() (bool, bool) { return false, false }
-
-
-func (f partialField[T]) String() (string, bool) { return "", false }
-
-func (f partialField[T]) Binary() ([]byte, bool) { return nil, false }
 
+func makePartialFieldLocal[T any] (name string, value T) partialField[T]{
+	return partialField[T]{
+		name  : name,
+		valuer: makeLocalValuer[T](value) }}
 
-func (f partialField[T]) Int  () (int, bool) { return 0, false }
+func makePartialFieldDefer[T any] (name string, valueFn func() T) partialField[T] {
+	return partialField[T]{
+		name  : name,
+		valuer: makeDeferValuer[T](valueFn),
+	}
+}
 
-func (f partialField[T]) Uint () (uint, bool) { return 0, false }
+func makePartialFieldOnce [T any] (name string, valueFn func() T) partialField[T] {
+	return partialField[T]{
+		name  : name,
+		valuer: newOnceValuer[T](valueFn),
+	}
+}
 
-func (f partialField[T]) Float() (float64, bool) { return 0, false }
 
 
-func (f partialField[T]) Time 	 () (time.Time, bool) { return g.timeZero, false }
+func (f partialField[T]) Name() string {
+	return f.name }
 
-func (f partialField[T]) Duration() (time.Duration, bool) { return 0, false }
 
 
-func (f partialField[T]) Error	 () (error, bool) { return nil, false }
 
-func (f partialField[T]) Reflect() (reflect.Value, bool) { return g.reflectZero, false }
 
+func (_ partialField[T]) Bool	 () (bool, bool) { return false, false }
+func (_ partialField[T]) String  () (string, bool) { return "", false }
+func (_ partialField[T]) Binary	 () ([]byte, bool) { return nil, false }
+func (_ partialField[T]) Int  	 () (int, bool) { return 0, false }
+func (_ partialField[T]) Uint 	 () (uint, bool) { return 0, false }
+func (_ partialField[T]) Float	 () (float64, bool) { return 0, false }
+func (_ partialField[T]) Time 	 () (time.Time, bool) { return g.timeZero, false }
+func (_ partialField[T]) Duration() (time.Duration, bool) { return 0, false }
+func (_ partialField[T]) Error	 () (error, bool) { return nil, false }
+func (_ partialField[T]) Reflect () (reflect.Value, bool) { return g.reflectZero, false }

core/aflds/type_resolver.go

@@ -30,10 +30,10 @@ import (
 
 type (
 
-	// NativeResolver es una interfaz que define métodos para resolver
+	// typeResolver es una interfaz que define métodos para resolver
 	// y obtener valores nativos de diferentes tipos, junto con un indicador
 	// de éxito para indicar si la resolución fue exitosa o no.
-	NativeResolver interface {
+	typeResolver interface {
 
 		// Bool intenta resolver y devolver el valor como un booleano.
 		// Retorna el valor booleano y un indicador de éxito.

core/aflds/valuer.go

@@ -28,8 +28,8 @@ type (
 
 	valuer [T any] interface {
 		valuerKind() Kind
-		native    () T
-		Value 	  () any
+		Native	() T
+		Value 	() any
 	}
 
 )

core/aflds/valuer_defer.go

@@ -34,11 +34,11 @@ type (
 )
 
 
-func newDeferValuer [T any] (valueFn func() T) *deferValuer[T] {
+func makeDeferValuer[T any] (valueFn func() T) deferValuer[T] {
 	if valueFn == nil {
 		panic(G.ErrInvalidDeferFunc)
 	}
-	return &deferValuer[T]{
+	return deferValuer[T]{
 		valueFn : valueFn }}
 
 
@@ -46,7 +46,7 @@ func newDeferValuer [T any] (valueFn func() T) *deferValuer[T] {
 func (_ deferValuer[T]) valuerKind() Kind {
 	return KindDefer }
 
-func (v deferValuer[T]) native () T {
+func (v deferValuer[T]) Native() T {
 	return v.valueFn() }
 
 func (v deferValuer[T]) Value () any {

core/aflds/valuer_local.go

@@ -34,8 +34,8 @@ type (
 )
 
 
-func newLocalValuer [T any] (value T) *localValuer[T] {
-	return &localValuer[T]{
+func makeLocalValuer[T any] (value T) localValuer[T] {
+	return localValuer[T]{
 		value : value }}
 
 
@@ -43,7 +43,7 @@ func newLocalValuer [T any] (value T) *localValuer[T] {
 func (_ localValuer[T]) valuerKind() Kind {
 	return 0 }
 
-func (v localValuer[T]) native () T {
+func (v localValuer[T]) Native() T {
 	return v.value }
 
 func (v localValuer[T]) Value () any {

core/aflds/valuer_once.go

@@ -0,0 +1,81 @@
+// ------------------------------------------------------------------------
+// ℹ️ Project active3
+// 🔗 Active Thing (activething.com) git.activething.com/go
+//
+//    File name  valuer_once.go
+// ✍️ Created by DEV
+// 📅 Modified   03/05/2024
+//
+// 🔒 Copyright 2024 activething.com
+//  
+// 📜 LICENSE --------------------------------------------------------------
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ------------------------------------------------------------------------
+
+package aflds
+
+import "sync"
+
+type (
+
+
+	onceValuer [T any] struct {
+		once   	sync.Once
+		result 	T
+		fail 	any
+		ok     	bool
+		onceFn 	func()
+
+	}
+)
+
+
+func newOnceValuer[T any] (valueFn func() T) *onceValuer[T] {
+	if valueFn == nil {
+		panic(G.ErrInvalidDeferFunc)
+	}
+
+	ov := onceValuer[T]{}
+
+	ov.onceFn = func() {
+		defer func(v *onceValuer[T]) {
+			if !v.ok {
+				v.fail = recover()
+				panic(v.fail)
+			}
+		}(&ov)
+		ov.result = valueFn()
+		valueFn = nil
+		ov.ok = true
+	}
+
+	return &ov
+}
+
+
+
+func (_ *onceValuer[T]) valuerKind() Kind {
+	return KindDeferOnce }
+
+
+func (v *onceValuer[T]) Native() T {
+	v.once.Do(v.onceFn)
+	if !v.ok {
+		panic(v.fail)
+	}
+	return v.result
+}
+
+func (v *onceValuer[T]) Value () any {
+	return v.Native() }
+