SVI Рабочее сохранение

v4/kern_test.go

@@ -55,7 +55,7 @@ func (sf *tester) new() {
 	sf.new3()
 
 	_ = NewOk("test ok")
-	_ = NewErr[core_spec.EBool](defs.NewErr("test err"))
+	_ = NewErr[core_spec.EBool](defs.Err("test err"))
 	_ = NewSome("test err")
 	_ = NewNone[int64]()
 

v4/lev0/defs/defs.go

@@ -111,54 +111,54 @@ type IErr interface {
 	IsErr() bool
 }
 
-// Err -- обёрнутая ошибка.
-type Err struct {
+// KErr -- обёрнутая ошибка.
+type KErr struct {
 	err error
 }
 
-// NewErr -- создать новую обёрнутую ошибку.
-func NewErr(msg ATxt, arg ...any) IErr {
+// Err -- создать новую обёрнутую ошибку.
+func Err(msg ATxt, arg ...any) IErr {
 	err := fmt.Errorf(string(msg), arg...)
-	return &Err{err}
+	return &KErr{err}
 }
 
 // WrapErr -- возвращает обёрнутую ошибку.
 func WrapErr(err error) IErr {
-	return &Err{err}
+	return &KErr{err}
 }
 
 // Rune -- возвращает внутреннюю строку в виде рун.
-func (e *Err) Rune() []rune {
+func (e *KErr) Rune() []rune {
 	return []rune(e.err.Error())
 }
 
 // Byte -- возвращает байты из ошибки.
-func (e *Err) Byte() []byte {
+func (e *KErr) Byte() []byte {
 	return []byte(e.err.Error())
 }
 
 // IsErr -- возвращает true, если ошибка.
-func (e *Err) IsErr() bool {
+func (e *KErr) IsErr() bool {
 	return e.err != nil
 }
 
 // String -- возвращает строковое представление ошибки.
-func (e *Err) String() string {
+func (e *KErr) String() string {
 	return e.err.Error()
 }
 
 // Error -- возвращает хранимую ошибку.
-func (e *Err) Error() string {
+func (e *KErr) Error() string {
 	return e.err.Error()
 }
 
 // Get -- возвращает строку по требованию для ошибки.
-func (e *Err) Get() ATxt {
+func (e *KErr) Get() ATxt {
 	return ATxt(e.err.Error())
 }
 
 // Len -- возвращает длину ошибки.
-func (e *Err) Len() Int {
+func (e *KErr) Len() Int {
 	return Int(len(e.err.Error()))
 }
 

v4/lev0/result/result.go

@@ -61,7 +61,7 @@ func WrapErr[T any](res mKs.IResult[T], err defs.IErr) mKs.IResult[T] {
 	mKh.Hassert(res.IsErr(), str7)
 	mKh.Hassert(err != nil, str8)
 	err0 := res.Err() // Чтобы не было паники при финализации и обернуть ошибку
-	err = defs.NewErr("%v, err=\n\t%w", err0, err)
+	err = defs.Err("%v, err=\n\t%w", err0, err)
 	sf := NewErr[T](err)
 	return sf
 }

v4/lev0/result/result_test.go

@@ -63,21 +63,21 @@ func (sf *tester) createErrGood1() {
 			sf.t.Fatalf("createErrGood1(): panic=%v", _panic)
 		}
 	}()
-	err := defs.NewErr("test err")
-	res := NewErr[string](err)
+	err := defs.Err("test err")
+	res := NewErr[defs.IErr](err)
 	if res.IsOk() {
 		sf.t.Fatalf("createErrGood1(): is ok")
 	}
 	if !res.IsErr() {
 		sf.t.Fatalf("createErrGood1(): not err")
 	}
-	if val := res.OkOr("test2"); val != "test2" {
+	if val := res.OkOr(defs.Err("test2")); val.Get() != "test2" {
 		sf.t.Fatalf("createErrGood1(): val bad")
 	}
-	if val := res.OkOr("test1"); val != "test1" {
+	if val := res.OkOr(defs.Err("test1")); val.Get() != "test1" {
 		sf.t.Fatalf("createErrGood1(): val bad")
 	}
-	if val := res.OkOrFn(sf.fnWrap2); val != "test5" {
+	if val := res.OkOrFn(sf.fnWrap2); val.Get() != "test5" {
 		sf.t.Fatalf("createErrGood1(): val bad")
 	}
 	if err := res.Err(); err == nil {
@@ -108,7 +108,7 @@ var (
 
 func (sf *tester) assert2() {
 	sf.t.Log("assert2")
-	err := defs.NewErr("test_error")
+	err := defs.Err("test_error")
 	res := NewErr[mKs.EBool](err)
 	defer func() {
 		if _panic := recover(); _panic == nil {
@@ -122,31 +122,31 @@ var (
 	str3 = defs.Txt("test hassert2")
 )
 
-func (sf *tester) hassert2(res mKs.IResult[string]) {
+func (sf *tester) hassert2(res mKs.IResult[defs.IErr]) {
 	sf.t.Log("hassert2")
 	defer func() {
 		if _panic := recover(); _panic == nil {
 			sf.t.Fatalf("assert(): panic==nil")
 		}
 	}()
-	res.Hassert(str3)
+	_ = res.Hassert(str3)
 }
 
 var (
 	str4 = defs.Txt("test assert")
 )
 
-func (sf *tester) hassert(res mKs.IResult[string]) {
+func (sf *tester) hassert(res mKs.IResult[defs.IErr]) {
 	sf.t.Log("hassert")
 	defer func() {
 		if _panic := recover(); _panic == nil {
 			sf.t.Fatalf("hassert(): panic==nil")
 		}
 	}()
-	res.Hassert(str4)
+	_ = res.Hassert(str4)
 }
 
-func (sf *tester) unwrapErr(res mKs.IResult[string]) {
+func (sf *tester) unwrapErr(res mKs.IResult[defs.IErr]) {
 	sf.t.Log("unwrapErr")
 	defer func() {
 		if _panic := recover(); _panic == nil {
@@ -168,8 +168,8 @@ func (sf *tester) createErrBad1() {
 	_ = NewErr[mKs.EBool](err)
 }
 
-const (
-	str = "test val"
+var (
+	str = defs.Txt("test val")
 )
 
 func (sf *tester) createOkGood2() {
@@ -189,16 +189,17 @@ func (sf *tester) createOkGood2() {
 	if val := res.Ok(); val != str {
 		sf.t.Fatalf("createOkGood1(): val bad")
 	}
-	if val := res.OkOr("test1"); val != str {
+	txt1:=defs.Txt("test1")
+	if val := res.OkOr(txt1); val != str {
 		sf.t.Fatalf("createOkGood1(): val bad")
 	}
-	if val := res.OkOr("test1"); val != str {
+	if val := res.OkOr(txt1); val != str {
 		sf.t.Fatalf("createOkGood1(): val bad")
 	}
 	if val := res.OkOrFn(sf.fnWrap); val != str {
 		sf.t.Fatalf("createOkGood1(): val bad")
 	}
-	res0 := NewErr[any](defs.NewErr("test_error"))
+	res0 := NewErr[any](defs.Err("test_error"))
 	if err := res0.Err(); err == nil {
 		sf.t.Fatalf("createOkGood1(): err==nil")
 	}
@@ -208,13 +209,13 @@ func (sf *tester) createOkGood2() {
 }
 
 // Функция высшего порядка для замещения ошибки.
-func (sf *tester) fnWrap2() string {
-	return "test5"
+func (sf *tester) fnWrap2() defs.IErr {
+	return defs.Err("test5")
 }
 
 // Функция высшего порядка для замещения ошибки.
-func (sf *tester) fnWrap() string {
-	return "test1"
+func (sf *tester) fnWrap() *defs.KTxt {
+	return defs.Txt("test1")
 }
 
 func (sf *tester) createOkGood1() {

v4/lev1/kint/kint.go

@@ -54,7 +54,7 @@ func (sf *KernInt) Reset() {
 func (sf *KernInt) FromStr(strVal defs.ITxtFix) mL0.IResult[defs.Int] {
 	iVal, err := strconv.Atoi(strVal.String())
 	if err != nil {
-		err := defs.NewErr("KInt.FromStr(): vak(%v) bad, err=\n\t%w", strVal, err)
+		err := defs.Err("KInt.FromStr(): vak(%v) bad, err=\n\t%w", strVal, err)
 		return mL0.NewErr[defs.Int](err)
 	}
 	sf.val = defs.Int(iVal)
@@ -70,14 +70,14 @@ func (sf *KernInt) ToStr() defs.ITxtFix {
 func (sf *KernInt) FromByte(binData []byte) mL0.IResult[defs.Int] {
 	lenBin := len(binData)
 	if lenBin < 8 {
-		err := defs.NewErr("KInt.FromByte(): len(%v) bytes shorts", lenBin)
+		err := defs.Err("KInt.FromByte(): len(%v) bytes shorts", lenBin)
 		return mL0.NewErr[defs.Int](err)
 	}
 	var signed int64
 	buf := bytes.NewReader(binData)
 	err := binary.Read(buf, binary.BigEndian, &signed)
 	if err != nil {
-		err := defs.NewErr("KInt.FromByte(): in read []byte, err=\n\t%w", err)
+		err := defs.Err("KInt.FromByte(): in read []byte, err=\n\t%w", err)
 		return mL0.NewErr[defs.Int](err)
 	}
 	sf.val = defs.Int(signed)
@@ -111,7 +111,7 @@ func (sf *KernInt) Getenv(env defs.ITxtFix) core_spec.IResult[defs.Int] {
 	strVal := defs.ATxt(os.Getenv(env.String()))
 	res := sf.FromStr(defs.Txt(strVal))
 	if res.IsErr() {
-		err := defs.NewErr("safeInt.Getenv(): from env %v, err=\n\t%w", env, res.Err())
+		err := defs.Err("safeInt.Getenv(): from env %v, err=\n\t%w", env, res.Err())
 		return mL0.NewErr[defs.Int](err)
 	}
 	return mL0.NewOk(sf.val)

v4/lev1/log_buf/log_buf_test.go

@@ -43,7 +43,7 @@ func (sf *tester) new() {
 	_msg = defs.Txt("test msg: %v", 47)
 	sf.log.Warn(_msg)
 	for i := range 120 {
-		err := defs.NewErr("test err: %v", i)
+		err := defs.Err("test err: %v", i)
 		sf.log.Err(err)
 	}
 	_ = sf.log.Get(120)

v4/lev1/log_dict_topic/log_dict_topic.go

@@ -19,7 +19,7 @@ type LogDictTopic struct {
 // NewLogDictTopic -- возвращает новый словарь топиков для логирования.
 func NewLogDictTopic(clientBus bus_spec.IBusClient) mL0.IResult[*LogDictTopic] {
 	if clientBus == nil {
-		err := defs.NewErr("NewLogDictTopic(): clientBus == nil")
+		err := defs.Err("NewLogDictTopic(): clientBus == nil")
 		return mL0.NewErr[*LogDictTopic](err)
 	}
 	sf := &LogDictTopic{

v4/lev1/safe_bool/safe_bool.go

@@ -31,7 +31,7 @@ func NewSafeBoolFromStr(strVal defs.ITxtFix) mL0.IResult[core_spec.ISafeBool] {
 	sf := NewSafeBool(false)
 	res := sf.FromStr(strVal)
 	if res.IsErr() {
-		err := defs.NewErr("NewSafeBoolFromStr(): in parse str(%v), err=\n\t%w", strVal, res.Err())
+		err := defs.Err("NewSafeBoolFromStr(): in parse str(%v), err=\n\t%w", strVal, res.Err())
 		return mL0.NewErr[core_spec.ISafeBool](err)
 	}
 	return mL0.NewOk(sf)
@@ -42,7 +42,7 @@ func NewSafeBoolGetenv(env defs.ITxtFix) core_spec.IResult[core_spec.ISafeBool]
 	sf := NewSafeBool(false)
 	res := sf.Getenv(env)
 	if res.IsErr() {
-		err := defs.NewErr("NewSafeBoolGetenv(): in parse env(%v), err=\n\t%w", env, res.Err())
+		err := defs.Err("NewSafeBoolGetenv(): in parse env(%v), err=\n\t%w", env, res.Err())
 		return mL0.NewErr[core_spec.ISafeBool](err)
 	}
 	return mL0.NewOk(sf)
@@ -80,7 +80,7 @@ func (sf *safeBool) FromStr(strVal defs.ITxtFix) core_spec.IResult[core_spec.EBo
 	case "false":
 		sf.val = false
 	default:
-		err := defs.NewErr("safeBool.FromStr(): val(%v) bad", strVal)
+		err := defs.Err("safeBool.FromStr(): val(%v) bad", strVal)
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	return mL0.NewOk(ebool.NewEBool(sf.val))
@@ -91,7 +91,7 @@ func (sf *safeBool) Getenv(env defs.ITxtFix) mL0.IResult[core_spec.EBool] {
 	strVal := defs.ATxt(os.Getenv(env.String()))
 	res := sf.FromStr(defs.Txt(strVal))
 	if res.IsErr() {
-		err := defs.NewErr("safeBool.Getenv(): from env %v, err=\n\t%w", env, res.Err())
+		err := defs.Err("safeBool.Getenv(): from env %v, err=\n\t%w", env, res.Err())
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	return res

v4/lev1/safe_bool_react/safe_bool_react.go

@@ -32,7 +32,7 @@ func NewSafeBoolReactFromStr(strVal defs.ITxtFix) mL0.IResult[core_spec.ISafeBoo
 	sf := NewSafeBoolReact()
 	res := sf.FromStr(strVal)
 	if res.IsErr() {
-		err := defs.NewErr("NewSafeBoolReactFromStr(): in parse str(%v), err=\n\t%w", strVal, res.Err())
+		err := defs.Err("NewSafeBoolReactFromStr(): in parse str(%v), err=\n\t%w", strVal, res.Err())
 		return mL0.NewErr[core_spec.ISafeBoolReact](err)
 	}
 	return mL0.NewOk(sf)
@@ -43,7 +43,7 @@ func NewSafeBoolGetenv(env defs.ITxtFix) mL0.IResult[core_spec.ISafeBoolReact] {
 	sf := NewSafeBoolReact()
 	res := sf.Getenv(env)
 	if res.IsErr() {
-		err := defs.NewErr("NewSafeBoolGetenv(): in parse env(%v), err=\n\t%w", env, res.Err())
+		err := defs.Err("NewSafeBoolGetenv(): in parse env(%v), err=\n\t%w", env, res.Err())
 		return mL0.NewErr[core_spec.ISafeBoolReact](err)
 	}
 	return mL0.NewOk(sf)
@@ -61,12 +61,12 @@ func (sf *safeBoolReact) Add(key defs.ITxtFix, fn func(core_spec.EBoolMut)) mL0.
 	sf.Lock()
 	defer sf.Unlock()
 	if key.Get() == "" {
-		err := defs.NewErr("safeBoolReact.Add(): key is empty")
+		err := defs.Err("safeBoolReact.Add(): key is empty")
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	_, isOk := sf.dict[key]
 	if isOk {
-		err := defs.NewErr("safeBoolReact.Add(): key(%v) already exists", key)
+		err := defs.Err("safeBoolReact.Add(): key(%v) already exists", key)
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	sf.dict[key] = fn
@@ -111,7 +111,7 @@ func (sf *safeBoolReact) FromStr(strVal defs.ITxtFix) core_spec.IResult[core_spe
 	case "false":
 		sf.val = false
 	default:
-		err := defs.NewErr("safeBoolReact.FromStr(): val(%v) bad", strVal)
+		err := defs.Err("safeBoolReact.FromStr(): val(%v) bad", strVal)
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	return mL0.NewOk(ebool.NewEBool(sf.val))
@@ -122,7 +122,7 @@ func (sf *safeBoolReact) Getenv(env defs.ITxtFix) mL0.IResult[core_spec.EBool] {
 	strVal := defs.ATxt(os.Getenv(env.String()))
 	res := sf.FromStr(defs.Txt(strVal))
 	if res.IsErr() {
-		err := defs.NewErr("safeBoolReact.Getenv(): from env %v, err=\n\t%w", env, res.Err())
+		err := defs.Err("safeBoolReact.Getenv(): from env %v, err=\n\t%w", env, res.Err())
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	return res

v4/lev1/safe_int/safe_int.go

@@ -29,7 +29,7 @@ func NewSafeIntFromStr(txtVal defs.ITxtFix) mL0.IResult[mKs.ISafeInt] {
 	sf := NewSafeInt(0)
 	res := sf.FromStr(txtVal)
 	if res.IsErr() {
-		err := defs.NewErr("NewSafeIntFromStr(): in parse str(%v), err=\n\t%w", txtVal, res.Err())
+		err := defs.Err("NewSafeIntFromStr(): in parse str(%v), err=\n\t%w", txtVal, res.Err())
 		return mL0.NewErr[mKs.ISafeInt](err)
 	}
 	return mL0.NewOk(sf)
@@ -40,7 +40,7 @@ func NewSafeIntGetenv(env defs.ITxtFix) mL0.IResult[mKs.ISafeInt] {
 	sf := NewSafeInt(0)
 	res := sf.Getenv(env)
 	if res.IsErr() {
-		err := defs.NewErr("NewSafeIntGetenv(): in parse env(%v), err=\n\t%w", env, res.Err())
+		err := defs.Err("NewSafeIntGetenv(): in parse env(%v), err=\n\t%w", env, res.Err())
 		return mL0.NewErr[mKs.ISafeInt](err)
 	}
 	return mL0.NewOk(sf)

v4/lev1/safe_string/safe_string.go

@@ -27,7 +27,7 @@ func NewSafeStringGetenv(env defs.ITxtFix) mL0.IResult[mKs.ISafeString] {
 	sf := NewSafeString()
 	res := sf.Getenv(env)
 	if res.IsErr() {
-		err := defs.NewErr("NewSafeStringGetenv(): in get from env(%v), err=\n\t%w", env, res.Err())
+		err := defs.Err("NewSafeStringGetenv(): in get from env(%v), err=\n\t%w", env, res.Err())
 		return mL0.NewErr[mKs.ISafeString](err)
 	}
 	return mL0.NewOk(sf)
@@ -65,7 +65,7 @@ func (sf *safeString) Reset() {
 func (sf *safeString) Getenv(env defs.ITxtFix) mL0.IResult[defs.ITxtFix] {
 	txtVal := defs.ATxt(os.Getenv(env.String()))
 	if txtVal == "" {
-		err := defs.NewErr("safeString.Getenv(): from env(%v), val is empty", env)
+		err := defs.Err("safeString.Getenv(): from env(%v), val is empty", env)
 		return mL0.NewErr[defs.ITxtFix](err)
 	}
 	sf.val = defs.Txt(txtVal)

v4/lev2/kchan/kchan.go

@@ -71,7 +71,7 @@ func (sf *KChan[T]) Read() core_spec.IResult[T] {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	if len(sf.lstMsg) == 0 {
-		err := defs.NewErr("KChan[T].Read(): empty list msg")
+		err := defs.Err("KChan[T].Read(): empty list msg")
 		return mL0.NewErr[T](err)
 	}
 

v4/lev2/kserv_http/kserv_http.go

@@ -154,7 +154,7 @@ func (sf *kServHttp) Run() {
 	fnListen := func() {
 		defer close(chErr)
 		err := sf.fiberApp.Listen(":" + strPort)
-		chErr <- defs.NewErr("kServHttp.Run().fnListen(): in listen server on port=%q, err=\n\t%v", strPort, err)
+		chErr <- defs.Err("kServHttp.Run().fnListen(): in listen server on port=%q, err=\n\t%v", strPort, err)
 	}
 	go fnListen()
 	go sf.fnChErr(chErr)
@@ -188,7 +188,7 @@ func (sf *kServHttp) Run() {
 func (sf *kServHttp) fnChErr(chErr <-chan defs.IErr) {
 	err := <-chErr
 	if err.Get() != "<nil>" {
-		err := defs.NewErr("kServHttp.fnChErr(): in listen, err=\n\t%w", err)
+		err := defs.Err("kServHttp.fnChErr(): in listen, err=\n\t%w", err)
 		sf.log.Err(err)
 		sf.kCtx.Cancel()
 	}

v4/lev2/kserv_http/kserv_http_test.go

@@ -44,7 +44,7 @@ func (sf *tester) close() {
 	}
 	kernServHttp.Run()
 	chErr := make(chan defs.IErr, 2)
-	chErr <- defs.NewErr("test err")
+	chErr <- defs.Err("test err")
 	close(chErr)
 	kernServHttp.fnChErr(chErr)
 }

v4/lev2/kserv_http_std/kserv_http_std.go

@@ -68,7 +68,7 @@ func (sf *kServHttpStd) Run() {
 		msg := defs.Txt("kServHttpStd.Run().fn(): run on http://%v", sf.server.Addr)
 		sf.log.Debug(msg)
 		if err := sf.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			err := defs.NewErr("kServHttpStd.Run.fn(): in work, err=\n\t%v", err)
+			err := defs.Err("kServHttpStd.Run.fn(): in work, err=\n\t%v", err)
 			sf.log.Err(err)
 		}
 	}()

v4/lev2/log_topic/log_topic.go

@@ -20,7 +20,7 @@ type LogTopic struct {
 func NewLogTopic(topic topic.ITopicFix, client bus_spec.IBusClient) mL0.IResult[*LogTopic] {
 	helpers.Hassert(topic != nil, "NewLogTopic(): topic==nil", []any{})
 	if client == nil {
-		err := defs.NewErr("NewLogTopic(): IBusClient==nil")
+		err := defs.Err("NewLogTopic(): IBusClient==nil")
 		return mL0.NewErr[*LogTopic](err)
 	}
 	sf := &LogTopic{
@@ -34,7 +34,7 @@ func NewLogTopic(topic topic.ITopicFix, client bus_spec.IBusClient) mL0.IResult[
 func (sf *LogTopic) Pub(binMsg []byte) mL0.IResult[mKs.EBool] {
 	res := sf.client.Publish(sf.topic, binMsg)
 	if res.IsErr() {
-		err := defs.NewErr("LogTopic.Pub(): in pub with client, err=\n\t%w", res.Err())
+		err := defs.Err("LogTopic.Pub(): in pub with client, err=\n\t%w", res.Err())
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	return res

v4/lev2/lsi/kstore_kv/kstore_kv.go

@@ -90,7 +90,7 @@ func (sf *kStoreKv) Set(rec store_ent.IRecKvFix) mL0.IResult[core_spec.EBool] {
 	}
 	err := sf.db.Update(fnSet)
 	if err != nil {
-		err := defs.NewErr("Set(): key=%v, err=\n\t%w", key, err)
+		err := defs.Err("Set(): key=%v, err=\n\t%w", key, err)
 		sf.log.Err(err)
 		return mL0.NewErr[core_spec.EBool](err)
 	}
@@ -113,7 +113,7 @@ func (sf *kStoreKv) Get(key store_ent.IStoreKeyFix) mL0.IResult[[]byte] {
 	}
 	err := sf.db.View(fnGet)
 	if err != nil {
-		err := defs.NewErr("Get(): key=%v, err=\n\t%v", key, err)
+		err := defs.Err("Get(): key=%v, err=\n\t%v", key, err)
 		sf.log.Err(err)
 		return mL0.NewErr[[]byte](err)
 	}
@@ -147,7 +147,7 @@ func (sf *kStoreKv) ByPrefix(prefix store_ent.IStoreKeyFix) core_spec.IResult[[]
 	}
 	err := sf.db.View(fnPrefix)
 	if err != nil {
-		err := defs.NewErr("ByPrefix(): in find, err=\n\t%w", err)
+		err := defs.Err("ByPrefix(): in find, err=\n\t%w", err)
 		return mL0.NewErr[[]store_ent.AStoreKey](err)
 	}
 	return mL0.NewOk(lstKey)
@@ -164,7 +164,7 @@ func (sf *kStoreKv) Delete(key store_ent.IStoreKeyFix) mL0.IResult[core_spec.EBo
 	}
 	err := sf.db.Update(fnDelete)
 	if err != nil {
-		err := defs.NewErr("Delete(): key=%v, err=\n\t%w", key, err)
+		err := defs.Err("Delete(): key=%v, err=\n\t%w", key, err)
 		sf.log.Err(err)
 		return mL0.NewErr[core_spec.EBool](err)
 	}

v4/lev2/lsi/store_ent/dict_rec/dict_rec.go

@@ -53,7 +53,7 @@ func (sf *DictRec) Get(key rec_key.IRecKeyFix) mL0.IOption[rec_kv.IRecKvFix] {
 // Set -- установка значения по ключу.
 func (sf *DictRec) Set(rec rec_kv.IRecKvFix) mL0.IResult[core_spec.EBool] {
 	if rec == nil {
-		err := defs.NewErr("DictRec.Set(): rec is nil")
+		err := defs.Err("DictRec.Set(): rec is nil")
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	sf.block.Lock()

v4/lev2/lti/bus_mock/mock_hand_serve/mock_hand_serve.go

@@ -40,7 +40,7 @@ func (sf *MockHandlerServe) FnBack(binMsg []byte) mL0.IResult[[]byte] {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	if sf.IsBad_.Get() {
-		err := defs.NewErr("FnBack(): isBad==true")
+		err := defs.Err("FnBack(): isBad==true")
 		return mL0.NewErr[[]byte](err)
 	}
 	sf.Msg_ = binMsg

v4/lev2/lti/kbus/dict_sub_hook/dict_sub_hook.go

@@ -33,7 +33,7 @@ func (sf *dictSubHook) Unsubscribe(handler bus_spec.IBusHandlerSubscribe) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	if handler == nil {
-		err := defs.NewErr("dictSubHook.Unsubscribe(): handler==nil")
+		err := defs.Err("dictSubHook.Unsubscribe(): handler==nil")
 		sf.kCtx.Log().Err(err)
 		return
 	}

v4/lev2/lti/kbus/dict_topic_serve/dict_topic_serve.go

@@ -39,13 +39,13 @@ func (sf *dictServe) Register(handler bus_spec.IBusHandlerServe) mL0.IResult[cor
 	sf.Lock()
 	defer sf.Unlock()
 	if handler == nil {
-		err := defs.NewErr("dictServe.Register(): IBusHandlerSubscribe==nil")
+		err := defs.Err("dictServe.Register(): IBusHandlerSubscribe==nil")
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	topic := handler.Topic()
 	isTwinRegister := sf.register(handler)
 	if isTwinRegister {
-		err := defs.NewErr("dictServe.Register(): handler of topic (%v) already register", topic.Get())
+		err := defs.Err("dictServe.Register(): handler of topic (%v) already register", topic.Get())
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	return mL0.NewOk(ebool.NewEBool(true))
@@ -56,7 +56,7 @@ func (sf *dictServe) Unregister(handler bus_spec.IBusHandlerServe) {
 	sf.Lock()
 	defer sf.Unlock()
 	if handler == nil {
-		err := defs.NewErr("dictServe.Unregister(): IBusHandlerSubscribe==nil")
+		err := defs.Err("dictServe.Unregister(): IBusHandlerSubscribe==nil")
 		sf.kCtx.Log().Err(err)
 		return
 	}
@@ -69,7 +69,7 @@ func (sf *dictServe) SendRequest(topic bus_ent.ITopicFix, binReq []byte) mL0.IRe
 	defer sf.RUnlock()
 	handler, isOk := sf.dictServe[topic.Get()]
 	if !isOk {
-		err := defs.NewErr("dictServe.SendRequest(): handler for topic (%v) not exists", topic.Get())
+		err := defs.Err("dictServe.SendRequest(): handler for topic (%v) not exists", topic.Get())
 		return mL0.NewErr[[]byte](err)
 	}
 	var (
@@ -85,7 +85,7 @@ func (sf *dictServe) SendRequest(topic bus_ent.ITopicFix, binReq []byte) mL0.IRe
 	go fnCall()
 	select {
 	case <-ctx.Done():
-		err := defs.NewErr("dictServe.SendRequest(): in call for topic (%v), err=\n\t%w", topic.Get(), ctx.Err())
+		err := defs.Err("dictServe.SendRequest(): in call for topic (%v), err=\n\t%w", topic.Get(), ctx.Err())
 		return mL0.NewErr[[]byte](err)
 	case res := <-chRes:
 		return res

v4/lev2/lti/kbus_base/kbus_base.go

@@ -98,13 +98,13 @@ func (sf *KBusBase) SendRequest(topic bus_ent.ITopicFix, binReq []byte) mL0.IRes
 	msg := defs.Txt("KBusBase.SendRequest(): topic='%v'", topic.Get())
 	sf.log.Debug(msg)
 	if !sf.IsWork_.Get() {
-		err := defs.NewErr("KBusBase.SendRequest():  topic='%v', bus already closed", topic.Get())
+		err := defs.Err("KBusBase.SendRequest():  topic='%v', bus already closed", topic.Get())
 		sf.log.Err(err)
 		return mL0.NewErr[[]byte](err)
 	}
 	res := sf.dictServe.SendRequest(topic, binReq)
 	if res.IsErr() {
-		err := defs.NewErr("KBusBase.SendRequest(): topic='%v', err=\n\t%w", topic.Get(), res.Err())
+		err := defs.Err("KBusBase.SendRequest(): topic='%v', err=\n\t%w", topic.Get(), res.Err())
 		sf.log.Err(err)
 		return mL0.NewErr[[]byte](err)
 	}
@@ -114,14 +114,14 @@ func (sf *KBusBase) SendRequest(topic bus_ent.ITopicFix, binReq []byte) mL0.IRes
 // RegisterServe -- регистрирует обработчики входящих запросов.
 func (sf *KBusBase) RegisterServe(handler bus_spec.IBusHandlerServe) mL0.IResult[core_spec.EBool] {
 	if handler == nil {
-		err := defs.NewErr("KBusBase.RegisterServe(): IBusHandlerServe==nil")
+		err := defs.Err("KBusBase.RegisterServe(): IBusHandlerServe==nil")
 		return mL0.NewErr[core_spec.EBool](err)
 	}
 	msg := defs.Txt("KBusBase.RegisterServe(): handler='%v'", handler.Name())
 	sf.log.Debug(msg)
 	res := sf.dictServe.Register(handler)
 	if res.IsErr() {
-		err := defs.NewErr("KBusBase.RegisterServe(): handler='%v', err=\n\t%w", handler.Name(), res.Err())
+		err := defs.Err("KBusBase.RegisterServe(): handler='%v', err=\n\t%w", handler.Name(), res.Err())
 		sf.log.Err(err)
 		return mL0.NewErr[core_spec.EBool](err)
 	}
@@ -133,7 +133,7 @@ func (sf *KBusBase) Publish(topic bus_ent.ITopicFix, binMsg []byte) mL0.IResult[
 	msg := defs.Txt("KBusBase.Publish(): topic='%v'", topic)
 	sf.log.Debug(msg)
 	if !sf.IsWork_.Get() {
-		err := defs.NewErr("KBusBase.Publish(): topic='%v',bus already closed", topic)
+		err := defs.Err("KBusBase.Publish(): topic='%v',bus already closed", topic)
 		sf.log.Err(err)
 		return mL0.NewErr[core_spec.EBool](err)
 	}

v4/lev2/lti/kbus_http/client_bus_http/client_bus_http.go

@@ -86,16 +86,16 @@ func (sf *ClientBusHttp) Unsubscribe(handler bus_spec.IBusHandlerSubscribe) {
 	resp := &dot.UnsubResp{}
 	err = json.Unmarshal(resBody.Ok(), resp)
 	if err != nil {
-		err := defs.NewErr("Unsubscribe(): in unmarshal response, err=\n\t%v", err)
+		err := defs.Err("Unsubscribe(): in unmarshal response, err=\n\t%v", err)
 		sf.log.Err(err)
 		return
 	}
 	if resp.Status_.Get() != "ok" {
-		err := defs.NewErr("Unsubscribe(): resp!='ok', err=\n\t%v", resp.Status_)
+		err := defs.Err("Unsubscribe(): resp!='ok', err=\n\t%v", resp.Status_)
 		sf.log.Err(err)
 	}
 	if resp.Uuid_ != req.Uuid_ {
-		err := defs.NewErr("Unsubscribe(): resp uuid(%v) bad", resp.Uuid_)
+		err := defs.Err("Unsubscribe(): resp uuid(%v) bad", resp.Uuid_)
 		sf.log.Err(err)
 	}
 }
@@ -118,21 +118,21 @@ func (sf *ClientBusHttp) Subscribe(handler bus_spec.IBusHandlerSubscribe) mKs.IR
 
 	resBody := sf.makePost(hReq)
 	if resBody.IsErr() {
-		err := defs.NewErr("ClientBusHttp.Subscribe(): in make POST-request, err=\n\t%w", err)
+		err := defs.Err("ClientBusHttp.Subscribe(): in make POST-request, err=\n\t%w", err)
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	resp := &dot.SubscribeResp{}
 	err = json.Unmarshal(resBody.Ok(), resp)
 	if err != nil {
-		err := defs.NewErr("ClientBusHttp.Subscribe(): in unmarshal response, err=\n\t%v", err)
+		err := defs.Err("ClientBusHttp.Subscribe(): in unmarshal response, err=\n\t%v", err)
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	if resp.Status_ != "ok" {
-		err := defs.NewErr("ClientBusHttp.Subscribe(): resp!='ok', err=\n\t%v", resp.Status_)
+		err := defs.Err("ClientBusHttp.Subscribe(): resp!='ok', err=\n\t%v", resp.Status_)
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	if resp.Uuid_ != req.Uuid_ {
-		err := defs.NewErr("ClientBusHttp.Subscribe(): resp uuid(%v) bad", resp.Uuid_)
+		err := defs.Err("ClientBusHttp.Subscribe(): resp uuid(%v) bad", resp.Uuid_)
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	res := sf.bus.Subscribe(handler)
@@ -157,21 +157,21 @@ func (sf *ClientBusHttp) SendRequest(topic bus_ent.ITopicFix, binReq []byte) mL0
 
 	resBody := sf.makePost(hReq)
 	if resBody.IsErr() {
-		err := defs.NewErr("ClientBusHttp.SendRequest(): in make request, err=\n\t%w", err)
+		err := defs.Err("ClientBusHttp.SendRequest(): in make request, err=\n\t%w", err)
 		return mL0.WrapErr(resBody, err)
 	}
 	resp := &dot.ServeResp{}
 	err = json.Unmarshal(resBody.Ok(), resp)
 	if err != nil {
-		err := defs.NewErr("ClientBusHttp.SendRequest(): in unmarshal response, err=\n\t%v", err)
+		err := defs.Err("ClientBusHttp.SendRequest(): in unmarshal response, err=\n\t%v", err)
 		return mL0.NewErr[[]byte](err)
 	}
 	if resp.Status_.Get() != "ok" {
-		err := defs.NewErr("ClientBusHttp.SendRequest(): resp!='ok', err=\n\t%v", resp.Status_)
+		err := defs.Err("ClientBusHttp.SendRequest(): resp!='ok', err=\n\t%v", resp.Status_)
 		return mL0.NewErr[[]byte](err)
 	}
 	if resp.Uuid_ != req.Uuid_ {
-		err := defs.NewErr("ClientBusHttp.SendRequest(): resp uuid(%v) bad", resp.Uuid_)
+		err := defs.Err("ClientBusHttp.SendRequest(): resp uuid(%v) bad", resp.Uuid_)
 		return mL0.NewErr[[]byte](err)
 	}
 	return mL0.NewOk(resp.BinResp_)
@@ -180,12 +180,12 @@ func (sf *ClientBusHttp) SendRequest(topic bus_ent.ITopicFix, binReq []byte) mL0
 // RegisterServe -- регистрирует в локальной шине обработчик.
 func (sf *ClientBusHttp) RegisterServe(handler bus_spec.IBusHandlerServe) mL0.IResult[mKs.EBool] {
 	if handler == nil {
-		err := defs.NewErr("ClientBusHttp.RegisterServe(): handler==nil")
+		err := defs.Err("ClientBusHttp.RegisterServe(): handler==nil")
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	res := sf.bus.RegisterServe(handler)
 	if res.IsErr() {
-		err := defs.NewErr("ClientBusHttp.RegisterServe(): in register serve to bus, err=\n\t%v", res.Err())
+		err := defs.Err("ClientBusHttp.RegisterServe(): in register serve to bus, err=\n\t%v", res.Err())
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	return mL0.NewOk(ebool.NewEBool(true))
@@ -209,21 +209,21 @@ func (sf *ClientBusHttp) Publish(topic bus_ent.ITopicFix, binMsg []byte) mL0.IRe
 
 	resBody := sf.makePost(hReq)
 	if resBody.IsErr() {
-		err := defs.NewErr("ClientBusHttp.Publish(): in make request, err=\n\t%w", err)
+		err := defs.Err("ClientBusHttp.Publish(): in make request, err=\n\t%w", err)
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	resp := &dot.PublishResp{}
 	err = json.Unmarshal(resBody.Ok(), resp)
 	if err != nil {
-		err := defs.NewErr("ClientBusHttp.Publish(): in unmarshal response, err=\n\t%v", err)
+		err := defs.Err("ClientBusHttp.Publish(): in unmarshal response, err=\n\t%v", err)
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	if resp.Status_ != "ok" {
-		err := defs.NewErr("ClientBusHttp.Publish(): resp!='ok', err=\n\t%v", resp.Status_)
+		err := defs.Err("ClientBusHttp.Publish(): resp!='ok', err=\n\t%v", resp.Status_)
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	if resp.Uuid_ != req.Uuid_ {
-		err := defs.NewErr("ClientBusHttp.Publish(): resp uuid(%v) bad", resp.Uuid_)
+		err := defs.Err("ClientBusHttp.Publish(): resp uuid(%v) bad", resp.Uuid_)
 		return mL0.NewErr[mKs.EBool](err)
 	}
 	return mL0.NewOk(ebool.NewEBool(true))
@@ -234,21 +234,21 @@ func (sf *ClientBusHttp) makePost(hReq *http.Request) mKs.IResult[[]byte] {
 	hReq.Header.Add("Content-Type", "application/json")
 	_resp, err := http.DefaultClient.Do(hReq)
 	if err != nil {
-		err := defs.NewErr("ClientBusHttp.makePost(): after request, err=\n\t%w", err)
+		err := defs.Err("ClientBusHttp.makePost(): after request, err=\n\t%w", err)
 		return mL0.NewErr[[]byte](err)
 	}
 	defer func() {
 		_ = _resp.Body.Close()
 	}()
 	if _resp.StatusCode != http.StatusOK {
-		err := defs.NewErr("ClientBusHttp.makePost(): url=%q, status=%q",
+		err := defs.Err("ClientBusHttp.makePost(): url=%q, status=%q",
 			hReq.URL, _resp.Status)
 		return mL0.NewErr[[]byte](err)
 	}
 
 	binBody, err := io.ReadAll(_resp.Body)
 	if err != nil {
-		err := defs.NewErr("ClientBusHttp.makePost(): after read body, err=\n\t%v",
+		err := defs.Err("ClientBusHttp.makePost(): after read body, err=\n\t%v",
 			err)
 		return mL0.NewErr[[]byte](err)
 	}

v4/lev2/lti/kbus_http/kbus_http.go

@@ -79,7 +79,7 @@ func (sf *kBusHttp) postSub(ctx fiber.Ctx) error {
 		}
 		resp.SelfCheck()
 		ctx.Response().SetStatusCode(http.StatusBadRequest)
-		err := defs.NewErr("kBusHttp.postSub(): in body parser, status=%q", resp.Status_)
+		err := defs.Err("kBusHttp.postSub(): in body parser, status=%q", resp.Status_)
 		sf.log.Err(err)
 		return ctx.JSON(resp)
 	}
@@ -121,7 +121,7 @@ func (sf *kBusHttp) postPublish(ctx fiber.Ctx) error {
 		}
 		resp.SelfCheck()
 		ctx.Response().SetStatusCode(http.StatusBadRequest)
-		err := defs.NewErr("postPublish(): in body parser, status=%v", resp.Status_)
+		err := defs.Err("postPublish(): in body parser, status=%v", resp.Status_)
 		sf.log.Err(err)
 		return ctx.JSON(resp)
 	}
@@ -161,7 +161,7 @@ func (sf *kBusHttp) postSendRequest(ctx fiber.Ctx) error {
 		}
 		resp.SelfCheck()
 		ctx.Response().SetStatusCode(http.StatusBadRequest)
-		err := defs.NewErr("kBusHttp.postSendRequest(): in body parser, status=%v", resp.Status_)
+		err := defs.Err("kBusHttp.postSendRequest(): in body parser, status=%v", resp.Status_)
 		sf.log.Err(err)
 		return ctx.JSON(resp)
 	}
@@ -202,7 +202,7 @@ func (sf *kBusHttp) postUnsub(ctx fiber.Ctx) error {
 		}
 		resp.SelfCheck()
 		ctx.Response().SetStatusCode(http.StatusBadRequest)
-		err := defs.NewErr("kBusHttp.postUnsub(): in body parser, status=%q", resp.Status_)
+		err := defs.Err("kBusHttp.postUnsub(): in body parser, status=%q", resp.Status_)
 		sf.log.Err(err)
 		return ctx.JSON(resp)
 	}

v4/lev3/mod_ent/mod_num/mod_num.go

@@ -47,7 +47,7 @@ func NewModuleNumFix() IModNumFix {
 func FromStr(strNumMod string) core_spec.IResult[IModNumFix] {
 	iNum, err := strconv.Atoi(strNumMod)
 	if err != nil {
-		err := defs.NewErr("FromStr(): strNumMod(%q) not nu,ber, err=\n\t%w", strNumMod, err)
+		err := defs.Err("FromStr(): strNumMod(%q) not nu,ber, err=\n\t%w", strNumMod, err)
 		return lev0.NewErr[IModNumFix](err)
 	}
 	sf := &moduleNum{

v4/lev3/mod_serv_http/btn_modules/btn_modules.go

@@ -45,7 +45,7 @@ var strBlockRow string
 func (sf *BtnModules) clickMonolit(dict map[string]string) mL0.IResult[string] {
 	optMonolit := sf.kCtx.Get(defs.Txt("monolit"))
 	if optMonolit.IsNone() {
-		err := defs.NewErr("clickMonolit(): monolit module not found")
+		err := defs.Err("clickMonolit(): monolit module not found")
 		return mL0.NewErr[string](err)
 	}
 	mon := optMonolit.Some().Val().(mod_spec.IKernelMonolit)

v4/lev3/mod_serv_http/http_api/http_api.go

@@ -20,7 +20,7 @@ func NewHttpApi() mL0.IResult[*HttpApi] {
 	kCtx := kctx.GetKernelCtx()
 	optFiber := kCtx.Get(defs.Txt("fiberApp"))
 	if optFiber.IsNone() {
-		err := defs.NewErr("NewHttpApi(): not found fiberApp in kernel ctx")
+		err := defs.Err("NewHttpApi(): not found fiberApp in kernel ctx")
 		return mL0.NewErr[*HttpApi](err)
 	}
 	fiberApp := optFiber.Some().Val().(*fiber.App)

v4/lev3/mod_serv_http/page_module/page_module.go

@@ -35,7 +35,7 @@ func GetPageModule() mL0.IResult[*PageModule] {
 	kCtx := kctx.GetKernelCtx()
 	optFiber := kCtx.Get(txtFiberApp)
 	if optFiber.IsNone() {
-		err := defs.NewErr("GetPageModule(): not found fiberApp in kernel ctx")
+		err := defs.Err("GetPageModule(): not found fiberApp in kernel ctx")
 		return mL0.NewErr[*PageModule](err)
 	}
 	fiberApp := optFiber.Some().Val().(*fiber.App)

v4/lev3/mod_wui/mod_wui.go

@@ -92,14 +92,14 @@ func (sf *ModuleWui) wuiClick(resp http.ResponseWriter, req *http.Request) {
 	id := strings.TrimPrefix(url.String(), "/wui/click/")
 	optWidget := sf.wCtx.Get(defs.Txt(id))
 	if optWidget == nil {
-		err := defs.NewErr("ModuleWui.wuiClick(): id(%v), widget not exists", id)
+		err := defs.Err("ModuleWui.wuiClick(): id(%v), widget not exists", id)
 		sf.log.Err(err)
 		_, _ = fmt.Fprint(resp, err)
 		return
 	}
 	widget1, isOk := optWidget.Some().(mWt.IWuiButton)
 	if !isOk {
-		strOut := defs.NewErr("ModuleWui.wuiClick(): widget(%T) not button",
+		strOut := defs.Err("ModuleWui.wuiClick(): widget(%T) not button",
 			optWidget.Some())
 		sf.log.Err(strOut)
 		_, _ = fmt.Fprint(resp, strOut)