refactored data-types to reduce plugin sizes
This commit is contained in:
@@ -1,27 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// string.go
|
||||
package kern
|
||||
|
||||
func IsBool(v any) (ok bool) {
|
||||
_, ok = v.(bool)
|
||||
return ok
|
||||
}
|
||||
|
||||
func ToBool(v any) (b bool, ok bool) {
|
||||
ok = true
|
||||
switch x := v.(type) {
|
||||
case string:
|
||||
b = len(x) > 0
|
||||
case float64:
|
||||
b = x != 0.0
|
||||
case int64:
|
||||
b = x != 0
|
||||
case bool:
|
||||
b = x
|
||||
default:
|
||||
ok = false
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// clone-value.go
|
||||
package kern
|
||||
|
||||
func Clone(v any) (c any) {
|
||||
if v == nil {
|
||||
return
|
||||
}
|
||||
switch unboxed := v.(type) {
|
||||
case int64:
|
||||
c = unboxed
|
||||
case float64:
|
||||
c = unboxed
|
||||
case string:
|
||||
c = unboxed
|
||||
case bool:
|
||||
c = unboxed
|
||||
case *ListType:
|
||||
c = unboxed.Clone()
|
||||
case *DictType:
|
||||
c = unboxed.Clone()
|
||||
case *LinkedList:
|
||||
c = unboxed.Clone()
|
||||
default:
|
||||
c = v
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// cloner.go
|
||||
package kern
|
||||
|
||||
type Cloner interface {
|
||||
Clone() any
|
||||
}
|
||||
|
||||
func IsCloner(v any) (ok bool) {
|
||||
_, ok = v.(Cloner)
|
||||
return
|
||||
}
|
||||
|
||||
func Clone(a any) (clone any) {
|
||||
if IsCloner(a) {
|
||||
clone = a.(Cloner).Clone()
|
||||
} else {
|
||||
clone = a
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -6,6 +6,7 @@ package kern
|
||||
|
||||
const (
|
||||
TypeAny = "any"
|
||||
TypeArray = "array"
|
||||
TypeNil = "nil"
|
||||
TypeBoolean = "boolean"
|
||||
TypeFloat = "float"
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
package kern
|
||||
|
||||
import "reflect"
|
||||
|
||||
func Equal(value1, value2 any) (equal bool) {
|
||||
if value1 == nil && value2 == nil {
|
||||
equal = true
|
||||
} else if value1 == nil || value2 == nil {
|
||||
equal = false
|
||||
} else if IsBool(value1) && IsBool(value2) {
|
||||
equal = value1.(bool) == value2.(bool)
|
||||
} else if IsList(value1) && IsList(value2) {
|
||||
ls1 := value1.(*ListType)
|
||||
ls2 := value2.(*ListType)
|
||||
equal = ls1.Equals(*ls2)
|
||||
} else if IsDict(value1) && IsDict(value2) {
|
||||
d1 := value1.(*DictType)
|
||||
d2 := value2.(*DictType)
|
||||
equal = d1.Equals(*d2)
|
||||
} else if IsLinkedList(value1) && IsLinkedList(value2) {
|
||||
ll1 := value1.(*LinkedList)
|
||||
ll2 := value2.(*LinkedList)
|
||||
equal = ll1.Equals(ll2)
|
||||
} else if IsInteger(value1) && IsInteger(value2) {
|
||||
equal = value1.(int64) == value2.(int64)
|
||||
} else if IsString(value1) && IsString(value2) {
|
||||
equal = value1.(string) == value2.(string)
|
||||
} else if IsFloat(value1) && IsFloat(value2) {
|
||||
equal = value1.(float64) == value2.(float64)
|
||||
} else if IsNumOrFract(value1) && IsNumOrFract(value2) {
|
||||
if eq, err := CmpAnyFract(value1, value2); err == nil {
|
||||
equal = eq == 0
|
||||
}
|
||||
} else if !reflect.DeepEqual(value1, value2) {
|
||||
equal = false
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// consts.go
|
||||
package kern
|
||||
|
||||
const MaxUint64Allowed = uint64(9_223_372_036_854_775_807)
|
||||
@@ -1,199 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// dict-type.go
|
||||
package kern
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const DictTypeName = "dict"
|
||||
|
||||
type DictType map[any]any
|
||||
|
||||
func IsDict(v any) (ok bool) {
|
||||
_, ok = v.(*DictType)
|
||||
return ok
|
||||
}
|
||||
|
||||
func MakeDict() (dict *DictType) {
|
||||
d := make(DictType)
|
||||
dict = &d
|
||||
return
|
||||
}
|
||||
|
||||
func NewDict(dictAny map[any]any) (dict *DictType) {
|
||||
var d DictType
|
||||
if dictAny != nil {
|
||||
d = make(DictType, len(dictAny))
|
||||
for i, item := range dictAny {
|
||||
d[i] = item
|
||||
}
|
||||
} else {
|
||||
d = make(DictType)
|
||||
}
|
||||
dict = &d
|
||||
return
|
||||
}
|
||||
|
||||
func newDict(dictAny map[any]Term) (dict *DictType) {
|
||||
// TODO Change with a call to NewDict()
|
||||
var d DictType
|
||||
if dictAny != nil {
|
||||
d = make(DictType, len(dictAny))
|
||||
for i, item := range dictAny {
|
||||
d[i] = item
|
||||
}
|
||||
} else {
|
||||
d = make(DictType)
|
||||
}
|
||||
dict = &d
|
||||
return
|
||||
}
|
||||
|
||||
func (dict *DictType) toMultiLine(sb *strings.Builder, opt FmtOpt) {
|
||||
indent := GetFormatIndent(opt)
|
||||
flags := GetFormatFlags(opt)
|
||||
//sb.WriteString(strings.Repeat(" ", indent))
|
||||
sb.WriteByte('{')
|
||||
|
||||
if len(*dict) > 0 {
|
||||
innerOpt := MakeFormatOptions(flags, indent+1)
|
||||
nest := strings.Repeat(" ", indent+1)
|
||||
sb.WriteByte('\n')
|
||||
|
||||
first := true
|
||||
for name, value := range *dict {
|
||||
if first {
|
||||
first = false
|
||||
} else {
|
||||
sb.WriteByte(',')
|
||||
sb.WriteByte('\n')
|
||||
}
|
||||
|
||||
sb.WriteString(nest)
|
||||
if key, ok := name.(string); ok {
|
||||
sb.WriteByte('"')
|
||||
sb.WriteString(key)
|
||||
sb.WriteByte('"')
|
||||
} else {
|
||||
fmt.Fprintf(sb, "%v", name)
|
||||
}
|
||||
sb.WriteString(": ")
|
||||
if f, ok := value.(Formatter); ok {
|
||||
sb.WriteString(f.ToString(innerOpt))
|
||||
} else if _, ok = value.(Functor); ok {
|
||||
sb.WriteString("func(){}")
|
||||
} else {
|
||||
fmt.Fprintf(sb, "%v", value)
|
||||
}
|
||||
}
|
||||
sb.WriteByte('\n')
|
||||
sb.WriteString(strings.Repeat(" ", indent))
|
||||
}
|
||||
sb.WriteString("}")
|
||||
}
|
||||
|
||||
func (dict *DictType) ToString(opt FmtOpt) string {
|
||||
var sb strings.Builder
|
||||
flags := GetFormatFlags(opt)
|
||||
if flags&MultiLine != 0 {
|
||||
dict.toMultiLine(&sb, opt)
|
||||
} else {
|
||||
sb.WriteByte('{')
|
||||
first := true
|
||||
for key, value := range *dict {
|
||||
if first {
|
||||
first = false
|
||||
} else {
|
||||
sb.WriteString(", ")
|
||||
}
|
||||
if s, ok := key.(string); ok {
|
||||
sb.WriteByte('"')
|
||||
sb.WriteString(s)
|
||||
sb.WriteByte('"')
|
||||
} else {
|
||||
fmt.Fprintf(&sb, "%v", key)
|
||||
}
|
||||
sb.WriteString(": ")
|
||||
if formatter, ok := value.(Formatter); ok {
|
||||
sb.WriteString(formatter.ToString(opt))
|
||||
} else if t, ok := value.(Term); ok {
|
||||
sb.WriteString(t.String())
|
||||
} else {
|
||||
fmt.Fprintf(&sb, "%#v", value)
|
||||
}
|
||||
}
|
||||
sb.WriteByte('}')
|
||||
}
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func (dict *DictType) String() string {
|
||||
return dict.ToString(0)
|
||||
}
|
||||
|
||||
func (dict *DictType) TypeName() string {
|
||||
return DictTypeName
|
||||
}
|
||||
|
||||
func (dict *DictType) HasKey(target any) (ok bool) {
|
||||
for key := range *dict {
|
||||
if ok = reflect.DeepEqual(key, target); ok {
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (dict *DictType) SetItem(key any, value any) {
|
||||
(*dict)[key] = value
|
||||
}
|
||||
|
||||
func (dict *DictType) GetItem(key any) (value any, exists bool) {
|
||||
value, exists = (*dict)[key]
|
||||
return
|
||||
}
|
||||
|
||||
func (dict *DictType) Clone() (c *DictType) {
|
||||
c = newDict(nil)
|
||||
for k, v := range *dict {
|
||||
(*c)[k] = Clone(v)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (dict *DictType) Merge(second *DictType) {
|
||||
if second != nil {
|
||||
for k, v := range *second {
|
||||
(*dict)[k] = v
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (dict *DictType) Equals(dict2 DictType) (answer bool) {
|
||||
if dict2 != nil && len(*dict) == len(dict2) {
|
||||
answer = true
|
||||
for key, value1 := range *dict {
|
||||
if value2, exists := dict2.GetItem(key); exists {
|
||||
if !Equal(value1, value2) {
|
||||
answer = false
|
||||
break
|
||||
}
|
||||
} else {
|
||||
answer = false
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
////////////////
|
||||
|
||||
type DictFormat interface {
|
||||
ToDict() *DictType
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// equaler.go
|
||||
package kern
|
||||
|
||||
type Equaler interface {
|
||||
EqualTo(other Equaler) bool
|
||||
}
|
||||
|
||||
func IsEqualer(v any) (ok bool) {
|
||||
_, ok = v.(Equaler)
|
||||
return
|
||||
}
|
||||
|
||||
func Equal(a, b any) (equal bool) {
|
||||
if IsEqualer(a) && IsEqualer(b) {
|
||||
equal = a.(Equaler).EqualTo(b.(Equaler))
|
||||
} else {
|
||||
equal = a == b
|
||||
}
|
||||
return
|
||||
}
|
||||
+1
-30
@@ -29,35 +29,6 @@ type ExprContext interface {
|
||||
RegisterFuncInfo(info ExprFunc)
|
||||
RegisterFunc(name string, f Functor, returnType string, param []ExprFuncParam) (funcInfo ExprFunc, err error)
|
||||
|
||||
ToDict() (dict *DictType)
|
||||
ToDict() (dict any) // must be a *DictType
|
||||
ToString(opt FmtOpt) string
|
||||
}
|
||||
|
||||
func ContextToDict(ctx ExprContext) (dict *DictType) {
|
||||
var keys []string
|
||||
// Variables
|
||||
keys = ctx.EnumVars(nil)
|
||||
vars := MakeDict()
|
||||
for _, key := range keys {
|
||||
value, _ := ctx.GetVar(key)
|
||||
vars.SetItem(key, value)
|
||||
}
|
||||
|
||||
// Functions
|
||||
keys = ctx.EnumFuncs(func(name string) bool { return true })
|
||||
funcs := MakeDict()
|
||||
for _, key := range keys {
|
||||
funcInfo, _ := ctx.GetFuncInfo(key)
|
||||
funcs.SetItem(key, funcInfo)
|
||||
}
|
||||
|
||||
dict = MakeDict()
|
||||
dict.SetItem("vars", vars)
|
||||
dict.SetItem("funcs", funcs)
|
||||
return
|
||||
}
|
||||
|
||||
func ContextToString(ctx ExprContext, opt FmtOpt) string {
|
||||
dict := ctx.ToDict()
|
||||
return dict.ToString(opt)
|
||||
}
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// float.go
|
||||
package kern
|
||||
|
||||
func IsFloat(v any) (ok bool) {
|
||||
_, ok = v.(float64)
|
||||
return ok
|
||||
}
|
||||
|
||||
func AnyFloat(v any) (float float64, ok bool) {
|
||||
ok = true
|
||||
switch floatval := v.(type) {
|
||||
case float32:
|
||||
float = float64(floatval)
|
||||
case float64:
|
||||
float = floatval
|
||||
default:
|
||||
ok = false
|
||||
}
|
||||
return
|
||||
}
|
||||
+4
-23
@@ -21,6 +21,10 @@ const (
|
||||
Base16
|
||||
)
|
||||
|
||||
type Formatter interface {
|
||||
ToString(options FmtOpt) string
|
||||
}
|
||||
|
||||
const (
|
||||
TruncateEllipsis = "(...)"
|
||||
MinTruncateSize = 10
|
||||
@@ -45,10 +49,6 @@ func GetFormatIndent(opt FmtOpt) int {
|
||||
return int(opt >> 16)
|
||||
}
|
||||
|
||||
type Formatter interface {
|
||||
ToString(options FmtOpt) string
|
||||
}
|
||||
|
||||
func Format(sb *strings.Builder, item any, opt FmtOpt) {
|
||||
if s, ok := item.(string); ok {
|
||||
sb.WriteByte('"')
|
||||
@@ -73,22 +73,3 @@ func GetFormatted(v any, opt FmtOpt) (text string) {
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
type Typer interface {
|
||||
TypeName() string
|
||||
}
|
||||
|
||||
func TypeName(v any) (name string) {
|
||||
if v == nil {
|
||||
name = "nil"
|
||||
} else if typer, ok := v.(Typer); ok {
|
||||
name = typer.TypeName()
|
||||
} else if IsInteger(v) {
|
||||
name = "integer"
|
||||
} else if IsFloat(v) {
|
||||
name = "float"
|
||||
} else {
|
||||
name = fmt.Sprintf("%T", v)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
@@ -1,385 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// fraction-type.go
|
||||
package kern
|
||||
|
||||
//https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"math"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type FractionType struct {
|
||||
num, den int64
|
||||
}
|
||||
|
||||
func NewFraction(num, den int64) *FractionType {
|
||||
num, den = simplifyIntegers(num, den)
|
||||
return &FractionType{num, den}
|
||||
}
|
||||
|
||||
func Float64ToFraction(f float64) (fract *FractionType, err error) {
|
||||
var sign string
|
||||
intPart, decPart := math.Modf(f)
|
||||
if decPart < 0.0 {
|
||||
sign = "-"
|
||||
intPart = -intPart
|
||||
decPart = -decPart
|
||||
}
|
||||
dec := fmt.Sprintf("%.12f", decPart)
|
||||
s := fmt.Sprintf("%s%.f%s", sign, intPart, dec[1:])
|
||||
return MakeGeneratingFraction(s)
|
||||
}
|
||||
|
||||
// Based on https://cs.opensource.google/go/go/+/refs/tags/go1.22.3:src/math/big/rat.go;l=39
|
||||
func MakeGeneratingFraction(s string) (f *FractionType, err error) {
|
||||
var num, den int64
|
||||
var sign int64 = 1
|
||||
var parts []string
|
||||
if len(s) == 0 {
|
||||
goto exit
|
||||
}
|
||||
switch s[0] {
|
||||
case '-':
|
||||
sign = int64(-1)
|
||||
s = s[1:]
|
||||
case '+':
|
||||
s = s[1:]
|
||||
}
|
||||
// if strings.HasSuffix(s, "()") {
|
||||
// s = s[0 : len(s)-2]
|
||||
// }
|
||||
s = strings.TrimSuffix(s, "()")
|
||||
parts = strings.SplitN(s, ".", 2)
|
||||
if num, err = strconv.ParseInt(parts[0], 10, 64); err != nil {
|
||||
return
|
||||
}
|
||||
if len(parts) == 1 {
|
||||
f = NewFraction(sign*num, 1)
|
||||
} else if len(parts) == 2 {
|
||||
subParts := strings.SplitN(parts[1], "(", 2)
|
||||
if len(subParts) == 1 {
|
||||
den = 1
|
||||
dec := parts[1]
|
||||
lsd := len(dec)
|
||||
for i := lsd - 1; i >= 0 && dec[i] == '0'; i-- {
|
||||
lsd--
|
||||
}
|
||||
for _, c := range dec[0:lsd] {
|
||||
if c < '0' || c > '9' {
|
||||
return nil, ErrExpectedGot("fract", "digit", c)
|
||||
}
|
||||
num = num*10 + int64(c-'0')
|
||||
den = den * 10
|
||||
}
|
||||
f = NewFraction(sign*num, den)
|
||||
} else if len(subParts) == 2 {
|
||||
sub := num
|
||||
mul := int64(1)
|
||||
for _, c := range subParts[0] {
|
||||
if c < '0' || c > '9' {
|
||||
return nil, ErrExpectedGot("fract", "digit", c)
|
||||
}
|
||||
num = num*10 + int64(c-'0')
|
||||
sub = sub*10 + int64(c-'0')
|
||||
mul *= 10
|
||||
}
|
||||
if len(subParts) == 2 {
|
||||
if s[len(s)-1] != ')' {
|
||||
goto exit
|
||||
}
|
||||
p := subParts[1][0 : len(subParts[1])-1]
|
||||
for _, c := range p {
|
||||
if c < '0' || c > '9' {
|
||||
return nil, ErrExpectedGot("fract", "digit", c)
|
||||
}
|
||||
num = num*10 + int64(c-'0')
|
||||
den = den*10 + 9
|
||||
}
|
||||
den *= mul
|
||||
}
|
||||
num -= sub
|
||||
f = NewFraction(sign*num, den)
|
||||
}
|
||||
}
|
||||
exit:
|
||||
if f == nil {
|
||||
err = errors.New("bad syntax")
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (f *FractionType) N() int64 {
|
||||
return f.num
|
||||
}
|
||||
|
||||
func (f *FractionType) D() int64 {
|
||||
return f.den
|
||||
}
|
||||
|
||||
func (f *FractionType) ToFloat() float64 {
|
||||
return float64(f.num) / float64(f.den)
|
||||
}
|
||||
|
||||
func (f *FractionType) String() string {
|
||||
return f.ToString(0)
|
||||
}
|
||||
|
||||
func (f *FractionType) ToString(opt FmtOpt) string {
|
||||
var sb strings.Builder
|
||||
if opt&MultiLine == 0 {
|
||||
sb.WriteString(fmt.Sprintf("%d:%d", f.num, f.den))
|
||||
} else {
|
||||
var sign, num string
|
||||
if f.num < 0 && opt&TTY == 0 {
|
||||
num = strconv.FormatInt(-f.num, 10)
|
||||
sign = "-"
|
||||
} else {
|
||||
num = strconv.FormatInt(f.num, 10)
|
||||
}
|
||||
den := strconv.FormatInt(f.den, 10)
|
||||
size := max(len(num), len(den))
|
||||
if opt&TTY != 0 {
|
||||
sNum := fmt.Sprintf("\x1b[4m%[1]*s\x1b[0m\n", -size, fmt.Sprintf("%[1]*s", (size+len(num))/2, sign+num))
|
||||
sb.WriteString(sNum)
|
||||
} else {
|
||||
if len(sign) > 0 {
|
||||
sb.WriteString(" ")
|
||||
}
|
||||
sb.WriteString(fmt.Sprintf("%[1]*s", -size, fmt.Sprintf("%[1]*s", (size+len(num))/2, num)))
|
||||
sb.WriteByte('\n')
|
||||
if len(sign) > 0 {
|
||||
sb.WriteString(sign)
|
||||
sb.WriteByte(' ')
|
||||
}
|
||||
sb.WriteString(strings.Repeat("-", size))
|
||||
sb.WriteByte('\n')
|
||||
if len(sign) > 0 {
|
||||
sb.WriteString(" ")
|
||||
}
|
||||
}
|
||||
sDen := fmt.Sprintf("%[1]*s", size, fmt.Sprintf("%[1]*s", (size+len(den))/2, den))
|
||||
sb.WriteString(sDen)
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func (f *FractionType) TypeName() string {
|
||||
return "fraction"
|
||||
}
|
||||
|
||||
// -------- fraction utility functions
|
||||
|
||||
// greatest common divider
|
||||
func Gcd(a, b int64) (g int64) {
|
||||
if a < 0 {
|
||||
a = -a
|
||||
}
|
||||
if b < 0 {
|
||||
b = -b
|
||||
}
|
||||
if a < b {
|
||||
a, b = b, a
|
||||
}
|
||||
r := a % b
|
||||
for r > 0 {
|
||||
a, b = b, r
|
||||
r = a % b
|
||||
}
|
||||
g = b
|
||||
return
|
||||
}
|
||||
|
||||
// lower common multiple
|
||||
func lcm(a, b int64) (l int64) {
|
||||
g := Gcd(a, b)
|
||||
l = a * b / g
|
||||
return
|
||||
}
|
||||
|
||||
// Sum two fractions
|
||||
func SumFract(f1, f2 *FractionType) (sum *FractionType) {
|
||||
m := lcm(f1.den, f2.den)
|
||||
sum = NewFraction(f1.num*(m/f1.den)+f2.num*(m/f2.den), m)
|
||||
return
|
||||
}
|
||||
|
||||
// Multiply two fractions
|
||||
func MulFract(f1, f2 *FractionType) (prod *FractionType) {
|
||||
prod = NewFraction(f1.num*f2.num, f1.den*f2.den)
|
||||
return
|
||||
}
|
||||
|
||||
func anyToFract(v any) (f *FractionType, err error) {
|
||||
var ok bool
|
||||
if f, ok = v.(*FractionType); !ok {
|
||||
if n, ok := v.(int64); ok {
|
||||
f = intToFraction(n)
|
||||
} else if dec, ok := v.(float64); ok {
|
||||
f, err = Float64ToFraction(dec)
|
||||
} else {
|
||||
err = ErrExpectedGot("fract", TypeFraction, v)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func anyPairToFract(v1, v2 any) (f1, f2 *FractionType, err error) {
|
||||
if f1, err = anyToFract(v1); err != nil {
|
||||
return
|
||||
}
|
||||
if f2, err = anyToFract(v2); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func SumAnyFract(af1, af2 any) (sum any, err error) {
|
||||
var f1, f2 *FractionType
|
||||
if f1, f2, err = anyPairToFract(af1, af2); err != nil {
|
||||
return
|
||||
}
|
||||
f := SumFract(f1, f2)
|
||||
if f.num == 0 {
|
||||
sum = 0
|
||||
} else {
|
||||
sum = simplifyFraction(f)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Returns
|
||||
//
|
||||
// <0 if af1 < af2
|
||||
// =0 if af1 == af2
|
||||
// >0 if af1 > af2
|
||||
// err if af1 or af2 is not convertible to fraction
|
||||
func CmpAnyFract(af1, af2 any) (result int, err error) {
|
||||
var f1, f2 *FractionType
|
||||
if f1, f2, err = anyPairToFract(af1, af2); err != nil {
|
||||
return
|
||||
}
|
||||
result = cmpFract(f1, f2)
|
||||
return
|
||||
}
|
||||
|
||||
// Returns
|
||||
//
|
||||
// <0 if af1 < af2
|
||||
// =0 if af1 == af2
|
||||
// >0 if af1 > af2
|
||||
func cmpFract(f1, f2 *FractionType) (result int) {
|
||||
if f1 != nil && f2 != nil {
|
||||
f2.num = -f2.num
|
||||
f := SumFract(f1, f2)
|
||||
if f.num < 0 {
|
||||
result = -1
|
||||
} else if f.num > 0 {
|
||||
result = 1
|
||||
} else {
|
||||
result = 0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func SubAnyFract(af1, af2 any) (sum any, err error) {
|
||||
var f1, f2 *FractionType
|
||||
if f1, f2, err = anyPairToFract(af1, af2); err != nil {
|
||||
return
|
||||
}
|
||||
f2.num = -f2.num
|
||||
f := SumFract(f1, f2)
|
||||
if f.num == 0 {
|
||||
sum = 0
|
||||
} else {
|
||||
sum = simplifyFraction(f)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func MulAnyFract(af1, af2 any) (prod any, err error) {
|
||||
var f1, f2 *FractionType
|
||||
if f1, f2, err = anyPairToFract(af1, af2); err != nil {
|
||||
return
|
||||
}
|
||||
if f1.num == 0 || f2.num == 0 {
|
||||
prod = 0
|
||||
} else {
|
||||
f := &FractionType{f1.num * f2.num, f1.den * f2.den}
|
||||
prod = simplifyFraction(f)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func DivAnyFract(af1, af2 any) (quot any, err error) {
|
||||
var f1, f2 *FractionType
|
||||
if f1, f2, err = anyPairToFract(af1, af2); err != nil {
|
||||
return
|
||||
}
|
||||
if f2.num == 0 {
|
||||
err = errors.New("division by zero")
|
||||
return
|
||||
}
|
||||
if f1.num == 0 || f2.den == 0 {
|
||||
quot = 0
|
||||
} else {
|
||||
f := &FractionType{f1.num * f2.den, f1.den * f2.num}
|
||||
quot = simplifyFraction(f)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func simplifyFraction(f *FractionType) (v any) {
|
||||
f.num, f.den = simplifyIntegers(f.num, f.den)
|
||||
if f.den == 1 {
|
||||
v = f.num
|
||||
} else {
|
||||
v = &FractionType{f.num, f.den}
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
func simplifyIntegers(num, den int64) (a, b int64) {
|
||||
if num == 0 {
|
||||
return 0, 1
|
||||
}
|
||||
if den == 0 {
|
||||
panic("fraction with denominator == 0")
|
||||
}
|
||||
if den < 0 {
|
||||
den = -den
|
||||
num = -num
|
||||
}
|
||||
g := Gcd(num, den)
|
||||
a = num / g
|
||||
b = den / g
|
||||
return
|
||||
}
|
||||
|
||||
func intToFraction(n int64) *FractionType {
|
||||
return &FractionType{n, 1}
|
||||
}
|
||||
|
||||
func IsFraction(v any) (ok bool) {
|
||||
_, ok = v.(*FractionType)
|
||||
return ok
|
||||
}
|
||||
|
||||
// func IsFract(v any) (ok bool) {
|
||||
// _, ok = v.(*FractionType)
|
||||
// return ok
|
||||
// }
|
||||
|
||||
func IsRational(v any) (ok bool) {
|
||||
if _, ok = v.(*FractionType); !ok {
|
||||
_, ok = v.(int64)
|
||||
}
|
||||
return ok
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// linked-list-type.go
|
||||
package kern
|
||||
|
||||
import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
const LinkedListTypeName = "lisked-list"
|
||||
const MaxUint64Allowed = uint64(9_223_372_036_854_775_807)
|
||||
|
||||
func IsLinkedList(v any) (ok bool) {
|
||||
_, ok = v.(*LinkedList)
|
||||
return ok
|
||||
}
|
||||
|
||||
func NewLinkedListA(listAny ...any) (list *LinkedList) {
|
||||
if listAny == nil {
|
||||
listAny = []any{}
|
||||
}
|
||||
list = NewLinkedList()
|
||||
for _, item := range listAny {
|
||||
list.PushBack(FixAnyNumber(item))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func LinkedListFromStrings(stringList []string) (list *LinkedList) {
|
||||
list = NewLinkedList()
|
||||
for _, s := range stringList {
|
||||
list.PushBack(s)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) ToString(opt FmtOpt) (s string) {
|
||||
indent := GetFormatIndent(opt)
|
||||
flags := GetFormatFlags(opt)
|
||||
|
||||
var sb strings.Builder
|
||||
sb.WriteString("[<")
|
||||
if ls.Len() > 0 {
|
||||
innerOpt := MakeFormatOptions(flags, indent+1)
|
||||
nest := strings.Repeat(" ", indent+1)
|
||||
|
||||
if flags&MultiLine != 0 {
|
||||
sb.WriteByte('\n')
|
||||
sb.WriteString(nest)
|
||||
}
|
||||
|
||||
i := 0
|
||||
for item := ls.FirstNode(); item != nil; item = item.Next() {
|
||||
if i > 0 {
|
||||
if flags&MultiLine != 0 {
|
||||
sb.WriteString(",\n")
|
||||
sb.WriteString(nest)
|
||||
} else {
|
||||
sb.WriteString(", ")
|
||||
}
|
||||
}
|
||||
// data := item.Data()
|
||||
// if s, ok := data.(string); ok {
|
||||
// sb.WriteByte('"')
|
||||
// sb.WriteString(s)
|
||||
// sb.WriteByte('"')
|
||||
// } else if formatter, ok := data.(Formatter); ok {
|
||||
// sb.WriteString(formatter.ToString(innerOpt))
|
||||
// } else {
|
||||
// fmt.Fprintf(&sb, "%v", data)
|
||||
// }
|
||||
Format(&sb, item.Data(), innerOpt)
|
||||
i++
|
||||
}
|
||||
if flags&MultiLine != 0 {
|
||||
sb.WriteByte('\n')
|
||||
sb.WriteString(strings.Repeat(" ", indent))
|
||||
}
|
||||
}
|
||||
sb.WriteString(">]")
|
||||
s = sb.String()
|
||||
if flags&Truncate != 0 && len(s) > TruncateSize {
|
||||
s = TruncateString(s)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) String() string {
|
||||
return ls.ToString(0)
|
||||
}
|
||||
|
||||
func (ls *LinkedList) TypeName() string {
|
||||
return LinkedListTypeName
|
||||
}
|
||||
|
||||
// func (ls *LinkedList) Contains(t *ListType) (answer bool) {
|
||||
// if len(*ls) >= len(*t) {
|
||||
// answer = true
|
||||
// for _, item := range *t {
|
||||
// if answer = ls.IndexDeepSameCmp(item) >= 0; !answer {
|
||||
// break
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// return
|
||||
// }
|
||||
|
||||
func (ls1 *LinkedList) Equals(ls2 *LinkedList) (answer bool) {
|
||||
if ls2 != nil && ls1.Len() == ls2.Len() {
|
||||
answer = true
|
||||
i2 := ls2.FirstNode()
|
||||
for i1 := ls1.FirstNode(); i1 != nil; i1 = i1.Next() {
|
||||
if !Equal(i1.Data(), i2.Data()) {
|
||||
answer = false
|
||||
break
|
||||
}
|
||||
i2 = i2.Next()
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls1 *LinkedList) Clone() (ls2 *LinkedList) {
|
||||
ls2 = NewLinkedListA()
|
||||
for i1 := ls1.FirstNode(); i1 != nil; i1 = i1.Next() {
|
||||
ls2.PushBack(Clone(i1.Data()))
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -1,284 +0,0 @@
|
||||
// simple-list project slist.go
|
||||
package kern
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
type ListNode struct {
|
||||
data any
|
||||
next *ListNode
|
||||
}
|
||||
|
||||
func (node *ListNode) Next() *ListNode {
|
||||
return node.next
|
||||
}
|
||||
|
||||
func (self *ListNode) Data() any {
|
||||
return self.data
|
||||
}
|
||||
|
||||
type LinkedList struct {
|
||||
count int
|
||||
first *ListNode
|
||||
last *ListNode
|
||||
}
|
||||
|
||||
func NewLinkedList() (list *LinkedList) {
|
||||
list = &LinkedList{0, nil, nil}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) Len() int {
|
||||
return ls.count
|
||||
}
|
||||
|
||||
func (ls *LinkedList) Empty() bool {
|
||||
return ls.count == 0
|
||||
}
|
||||
|
||||
func (ls *LinkedList) PushFront(data any) *ListNode {
|
||||
ls.first = &ListNode{data, ls.first}
|
||||
if ls.last == nil {
|
||||
ls.last = ls.first
|
||||
}
|
||||
ls.count++
|
||||
return ls.first
|
||||
}
|
||||
|
||||
func (ls *LinkedList) SeqPushFront(data any) (result *LinkedList) {
|
||||
switch seq := data.(type) {
|
||||
case Iterator:
|
||||
result = ls.IterPushFront(seq)
|
||||
default:
|
||||
ls.PushFront(data)
|
||||
result = ls
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) IterPushFront(it Iterator) *LinkedList {
|
||||
for item, err1 := it.Next(); err1 == nil; item, err1 = it.Next() {
|
||||
ls.PushFront(item)
|
||||
}
|
||||
return ls
|
||||
}
|
||||
|
||||
func (ls *LinkedList) PushBack(data any) (node *ListNode) {
|
||||
node = &ListNode{data, nil}
|
||||
if ls.last != nil {
|
||||
ls.last.next = node
|
||||
}
|
||||
ls.last = node
|
||||
if ls.first == nil {
|
||||
ls.first = node
|
||||
}
|
||||
ls.count++
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) SeqPushBack(data any) (result *LinkedList) {
|
||||
switch seq := data.(type) {
|
||||
case Iterator:
|
||||
result = ls.IterPushBack(seq)
|
||||
default:
|
||||
ls.PushBack(data)
|
||||
result = ls
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) IterPushBack(it Iterator) *LinkedList {
|
||||
for item, err1 := it.Next(); err1 == nil; item, err1 = it.Next() {
|
||||
ls.PushBack(item)
|
||||
}
|
||||
return ls
|
||||
}
|
||||
|
||||
func (ls *LinkedList) FirstNode() *ListNode {
|
||||
return ls.first
|
||||
}
|
||||
|
||||
func (ls *LinkedList) First() (data any, err error) {
|
||||
if ls.first != nil {
|
||||
data = ls.first.data
|
||||
} else {
|
||||
err = errorListEmpty()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) LastNode() *ListNode {
|
||||
return ls.last
|
||||
}
|
||||
|
||||
func (ls *LinkedList) Last() (data interface{}, err error) {
|
||||
if ls.last != nil {
|
||||
data = ls.last.data
|
||||
} else {
|
||||
err = errorListEmpty()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) NodeAt(index int) (node *ListNode, err error) {
|
||||
if ls.count == 0 {
|
||||
err = errorListEmpty()
|
||||
} else if index > ls.count {
|
||||
err = errorOutOfRange()
|
||||
} else if index == ls.count-1 {
|
||||
node = ls.last
|
||||
} else {
|
||||
current := ls.first
|
||||
for range index {
|
||||
current = current.next
|
||||
}
|
||||
node = current
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) At(index int) (data interface{}, err error) {
|
||||
node, err := ls.NodeAt(index)
|
||||
if err == nil {
|
||||
data = node.data
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) Insert(index int, data any) *ListNode {
|
||||
var prev *ListNode
|
||||
|
||||
prev = nil
|
||||
current := ls.first
|
||||
for pos := 0; current != nil && pos < index; pos++ {
|
||||
prev = current
|
||||
current = current.next
|
||||
}
|
||||
|
||||
node := &ListNode{data, current}
|
||||
|
||||
if prev != nil {
|
||||
prev.next = node
|
||||
}
|
||||
|
||||
if ls.first == current {
|
||||
ls.first = node
|
||||
}
|
||||
if node.next == nil {
|
||||
ls.last = node
|
||||
}
|
||||
ls.count++
|
||||
return node
|
||||
}
|
||||
|
||||
func (ls *LinkedList) PushBackStringArray(items []string) {
|
||||
for _, v := range items {
|
||||
ls.PushBack(v)
|
||||
}
|
||||
}
|
||||
|
||||
func (ls *LinkedList) Sub(start, end int) (subList *LinkedList) {
|
||||
subList = NewLinkedList()
|
||||
if node, err := ls.NodeAt(start); err == nil {
|
||||
for i := start; i < end && node != nil; i++ {
|
||||
subList.PushBack(node.data)
|
||||
node = node.next
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// type TraverseOperator func(index int, elem interface{}, userData interface{}) (err error)
|
||||
|
||||
// func (self *LinkedList) Traverse(op TraverseOperator, user_data interface{}) (err error) {
|
||||
// index := int(0)
|
||||
// for current := self.first; current != nil; current = current.next {
|
||||
// err = op(index, current.data, user_data)
|
||||
// if err != nil {
|
||||
// break
|
||||
// }
|
||||
// index++
|
||||
// }
|
||||
// return
|
||||
// }
|
||||
|
||||
// func (self *LinkedList) Traverse2(observer Observer, abortOnError bool) (err error) {
|
||||
// index := int(0)
|
||||
// for current := self.first; current != nil; current = current.next {
|
||||
// err = observer.Observe(current, index)
|
||||
// if err != nil && abortOnError {
|
||||
// break
|
||||
// }
|
||||
// index++
|
||||
// }
|
||||
// return
|
||||
// }
|
||||
|
||||
type EqualFunc func(current, target any) bool
|
||||
|
||||
func (ls *LinkedList) FindFirst(eqFunc EqualFunc, targetData any) (targetNode *ListNode) {
|
||||
for current := ls.first; current != nil && targetNode == nil; current = current.next {
|
||||
if eqFunc(current.data, targetData) {
|
||||
targetNode = current
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *LinkedList) FindNext(eqFunc EqualFunc, startNode *ListNode) (targetNode *ListNode) {
|
||||
if startNode != nil {
|
||||
for current := startNode.next; current != nil && targetNode == nil; current = current.next {
|
||||
if eqFunc(current.data, startNode.Data()) {
|
||||
targetNode = current
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// type DataFeeder func(user_data interface{}) interface{}
|
||||
// type NodeObserver func(node *ListNode, index int, userData interface{})
|
||||
|
||||
// func (self *LinkedList) FeedTail(feeder DataFeeder, feederUserData interface{}, observer NodeObserver, observerUserData interface{}) (count int) {
|
||||
// count = 0
|
||||
// for item := feeder(feederUserData); item != nil; item = feeder(feederUserData) {
|
||||
// // fmt.Println("Item", count, item)
|
||||
// node := self.PushBack(item)
|
||||
// if observer != nil {
|
||||
// observer(node, count, observerUserData)
|
||||
// }
|
||||
// count++
|
||||
// }
|
||||
// return
|
||||
// }
|
||||
|
||||
// func (self *LinkedList) FeedTail2(feeder Feeder, observer Observer, abortOnError bool) (count int, err error) {
|
||||
// count = 0
|
||||
// // item := feeder.Next()
|
||||
// for item, err1 := feeder.Next(); item != nil; item, err1 = feeder.Next() {
|
||||
// if err1 != nil {
|
||||
// if err == nil {
|
||||
// err = err1
|
||||
// }
|
||||
// if abortOnError {
|
||||
// break
|
||||
// }
|
||||
// }
|
||||
// // fmt.Println("Item", count, item)
|
||||
// node := self.PushBack(item)
|
||||
// if observer != nil {
|
||||
// observer.Observe(node, count)
|
||||
// }
|
||||
// count++
|
||||
// }
|
||||
// return
|
||||
// }
|
||||
|
||||
func errorListEmpty() error {
|
||||
return fmt.Errorf("List is empty")
|
||||
}
|
||||
|
||||
func errorOutOfRange() error {
|
||||
return fmt.Errorf("Out of range")
|
||||
}
|
||||
@@ -1,203 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// list-type.go
|
||||
package kern
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type ListType []any
|
||||
|
||||
func IsList(v any) (ok bool) {
|
||||
_, ok = v.(*ListType)
|
||||
return ok
|
||||
}
|
||||
|
||||
func NewListA(listAny ...any) (list *ListType) {
|
||||
if listAny == nil {
|
||||
listAny = []any{}
|
||||
}
|
||||
return NewList(listAny)
|
||||
}
|
||||
|
||||
func NewList(listAny []any) (list *ListType) {
|
||||
if listAny != nil {
|
||||
ls := make(ListType, len(listAny))
|
||||
copy(ls, listAny)
|
||||
list = &ls
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func MakeList(length, capacity int) (list *ListType) {
|
||||
if capacity < length {
|
||||
capacity = length
|
||||
}
|
||||
ls := make(ListType, length, capacity)
|
||||
list = &ls
|
||||
return
|
||||
}
|
||||
|
||||
func ListFromStrings(stringList []string) (list *ListType) {
|
||||
list = MakeList(len(stringList), 0)
|
||||
for i, s := range stringList {
|
||||
(*list)[i] = s
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *ListType) ToString(opt FmtOpt) (s string) {
|
||||
indent := GetFormatIndent(opt)
|
||||
flags := GetFormatFlags(opt)
|
||||
|
||||
var sb strings.Builder
|
||||
sb.WriteByte('[')
|
||||
if len(*ls) > 0 {
|
||||
innerOpt := MakeFormatOptions(flags, indent+1)
|
||||
nest := strings.Repeat(" ", indent+1)
|
||||
|
||||
if flags&MultiLine != 0 {
|
||||
sb.WriteByte('\n')
|
||||
sb.WriteString(nest)
|
||||
}
|
||||
for i, item := range []any(*ls) {
|
||||
if i > 0 {
|
||||
if flags&MultiLine != 0 {
|
||||
sb.WriteString(",\n")
|
||||
sb.WriteString(nest)
|
||||
} else {
|
||||
sb.WriteString(", ")
|
||||
}
|
||||
}
|
||||
Format(&sb, item, innerOpt)
|
||||
}
|
||||
if flags&MultiLine != 0 {
|
||||
sb.WriteByte('\n')
|
||||
sb.WriteString(strings.Repeat(" ", indent))
|
||||
}
|
||||
}
|
||||
sb.WriteByte(']')
|
||||
s = sb.String()
|
||||
if flags&Truncate != 0 && len(s) > TruncateSize {
|
||||
s = TruncateString(s)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *ListType) String() string {
|
||||
return ls.ToString(0)
|
||||
}
|
||||
|
||||
func (ls *ListType) TypeName() string {
|
||||
return "list"
|
||||
}
|
||||
|
||||
func (ls *ListType) Contains(t *ListType) (answer bool) {
|
||||
if len(*ls) >= len(*t) {
|
||||
answer = true
|
||||
for _, item := range *t {
|
||||
if answer = ls.IndexDeepSameCmp(item) >= 0; !answer {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *ListType) Equals(ls2 ListType) (answer bool) {
|
||||
if ls2 != nil && len(*ls) == len(ls2) {
|
||||
answer = true
|
||||
for index, i1 := range *ls {
|
||||
// if !reflect.DeepEqual(i1, ls2[index]) {
|
||||
// answer = false
|
||||
// break
|
||||
// }
|
||||
if !Equal(i1, ls2[index]) {
|
||||
answer = false
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls1 *ListType) Clone() (ls2 *ListType) {
|
||||
ls := make(ListType, len(*ls1))
|
||||
for i, item := range *ls1 {
|
||||
ls[i] = Clone(item)
|
||||
}
|
||||
ls2 = &ls
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *ListType) IndexDeepSameCmp(target any) (index int) {
|
||||
var eq bool
|
||||
var err error
|
||||
index = -1
|
||||
for i, item := range *ls {
|
||||
if eq, err = deepSame(item, target, SameContent); err != nil {
|
||||
break
|
||||
} else if eq {
|
||||
index = i
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func SameContent(a, b any) (same bool, err error) {
|
||||
la, _ := a.(*ListType)
|
||||
lb, _ := b.(*ListType)
|
||||
if len(*la) == len(*lb) {
|
||||
same = true
|
||||
for _, item := range *la {
|
||||
if pos := lb.IndexDeepSameCmp(item); pos < 0 {
|
||||
same = false
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func deepSame(a, b any, deepCmp DeepFuncTemplate) (eq bool, err error) {
|
||||
if IsNumOrFract(a) && IsNumOrFract(b) {
|
||||
if IsNumber(a) && IsNumber(b) {
|
||||
if IsInteger(a) && IsInteger(b) {
|
||||
li, _ := a.(int64)
|
||||
ri, _ := b.(int64)
|
||||
eq = li == ri
|
||||
} else {
|
||||
eq = NumAsFloat(a) == NumAsFloat(b)
|
||||
}
|
||||
} else {
|
||||
var cmp int
|
||||
if cmp, err = CmpAnyFract(a, b); err == nil {
|
||||
eq = cmp == 0
|
||||
}
|
||||
}
|
||||
} else if deepCmp != nil && IsList(a) && IsList(b) {
|
||||
eq, err = deepCmp(a, b)
|
||||
} else {
|
||||
eq = reflect.DeepEqual(a, b)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *ListType) SetItem(index int64, value any) (err error) {
|
||||
if index >= 0 && index < int64(len(*ls)) {
|
||||
(*ls)[index] = value
|
||||
} else {
|
||||
err = fmt.Errorf("index %d out of bounds (0, %d)", index, len(*ls)-1)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (ls *ListType) AppendItem(value any) {
|
||||
*ls = append(*ls, value)
|
||||
}
|
||||
-120
@@ -1,120 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// number.go
|
||||
package kern
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
func IsInteger(v any) (ok bool) {
|
||||
_, ok = v.(int64)
|
||||
return ok
|
||||
}
|
||||
|
||||
func IsNumber(v any) (ok bool) {
|
||||
return IsFloat(v) || IsInteger(v)
|
||||
}
|
||||
|
||||
func IsNumOrFract(v any) (ok bool) {
|
||||
return IsFloat(v) || IsInteger(v) || IsFraction(v)
|
||||
}
|
||||
|
||||
func IsNumberString(v any) (ok bool) {
|
||||
return IsString(v) || IsNumber(v)
|
||||
}
|
||||
|
||||
func NumAsFloat(v any) (f float64) {
|
||||
var ok bool
|
||||
if f, ok = v.(float64); !ok {
|
||||
if fract, ok := v.(*FractionType); ok {
|
||||
f = fract.ToFloat()
|
||||
} else {
|
||||
i, _ := v.(int64)
|
||||
f = float64(i)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func AnyInteger(v any) (i int64, ok bool) {
|
||||
ok = true
|
||||
switch intval := v.(type) {
|
||||
case int:
|
||||
i = int64(intval)
|
||||
case uint8:
|
||||
i = int64(intval)
|
||||
case uint16:
|
||||
i = int64(intval)
|
||||
case uint64:
|
||||
i = int64(intval)
|
||||
case uint32:
|
||||
i = int64(intval)
|
||||
case int8:
|
||||
i = int64(intval)
|
||||
case int16:
|
||||
i = int64(intval)
|
||||
case int32:
|
||||
i = int64(intval)
|
||||
case int64:
|
||||
i = intval
|
||||
default:
|
||||
ok = false
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func FixAnyNumber(v any) (fixed any) {
|
||||
switch unboxed := v.(type) {
|
||||
case int:
|
||||
fixed = int64(unboxed)
|
||||
case int8:
|
||||
fixed = int64(unboxed)
|
||||
case int16:
|
||||
fixed = int64(unboxed)
|
||||
case int32:
|
||||
fixed = int64(unboxed)
|
||||
case uint:
|
||||
fixed = int64(unboxed)
|
||||
case uint8:
|
||||
fixed = int64(unboxed)
|
||||
case uint16:
|
||||
fixed = int64(unboxed)
|
||||
case uint32:
|
||||
fixed = int64(unboxed)
|
||||
case uint64:
|
||||
if unboxed <= MaxUint64Allowed {
|
||||
fixed = int64(unboxed)
|
||||
} else {
|
||||
fixed = float64(unboxed)
|
||||
}
|
||||
case float32:
|
||||
fixed = float64(unboxed)
|
||||
default:
|
||||
fixed = v
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func ToGoInt(value any, description string) (i int, err error) {
|
||||
if valueInt64, ok := value.(int64); ok {
|
||||
i = int(valueInt64)
|
||||
} else if valueInt, ok := value.(int); ok {
|
||||
i = valueInt
|
||||
} else {
|
||||
err = fmt.Errorf("%s expected integer, got %s (%v)", description, TypeName(value), value)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func ToGoInt64(value any, description string) (i int64, err error) {
|
||||
if valueInt64, ok := value.(int64); ok {
|
||||
i = valueInt64
|
||||
} else if valueInt, ok := value.(int); ok {
|
||||
i = int64(valueInt)
|
||||
} else {
|
||||
err = fmt.Errorf("%s expected integer, got %s (%v)", description, TypeName(value), value)
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// string.go
|
||||
package kern
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
func IsString(v any) (ok bool) {
|
||||
_, ok = v.(string)
|
||||
return ok
|
||||
}
|
||||
|
||||
func ToGoString(value any, description string) (s string, err error) {
|
||||
if s, ok := value.(string); ok {
|
||||
return s, nil
|
||||
} else {
|
||||
err = fmt.Errorf("%s expected string, got %s (%v)", description, TypeName(value), value)
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// typer.go
|
||||
package kern
|
||||
|
||||
import "fmt"
|
||||
|
||||
type Typer interface {
|
||||
TypeName() string
|
||||
}
|
||||
|
||||
func TypeName(v any) (name string) {
|
||||
if v == nil {
|
||||
name = "nil"
|
||||
} else if typer, ok := v.(Typer); ok {
|
||||
name = typer.TypeName()
|
||||
} else if _, ok := v.(int64); ok {
|
||||
name = "integer"
|
||||
} else if _, ok := v.(float64); ok {
|
||||
name = "float"
|
||||
} else {
|
||||
name = fmt.Sprintf("%T", v)
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
|
||||
// All rights reserved.
|
||||
|
||||
// util.go
|
||||
package kern
|
||||
|
||||
func FixAnyNumber(v any) (fixed any) {
|
||||
switch unboxed := v.(type) {
|
||||
case int:
|
||||
fixed = int64(unboxed)
|
||||
case int8:
|
||||
fixed = int64(unboxed)
|
||||
case int16:
|
||||
fixed = int64(unboxed)
|
||||
case int32:
|
||||
fixed = int64(unboxed)
|
||||
case uint:
|
||||
fixed = int64(unboxed)
|
||||
case uint8:
|
||||
fixed = int64(unboxed)
|
||||
case uint16:
|
||||
fixed = int64(unboxed)
|
||||
case uint32:
|
||||
fixed = int64(unboxed)
|
||||
case uint64:
|
||||
if unboxed <= MaxUint64Allowed {
|
||||
fixed = int64(unboxed)
|
||||
} else {
|
||||
fixed = float64(unboxed)
|
||||
}
|
||||
case float32:
|
||||
fixed = float64(unboxed)
|
||||
default:
|
||||
fixed = v
|
||||
}
|
||||
return
|
||||
}
|
||||
Reference in New Issue
Block a user