lbatuska/goutils
1
1
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: naming (#1)

Browse Source
This commit was merged in pull request #1.
This commit is contained in:
Levente Nas
2024-09-25 09:42:06 +02:00
committed by GitHub
parent 23a8a9ee04
commit c4b6077e3a
11 changed files with 122 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
logger/ConsoleLogger.go
View File

@@ -5,11 +5,11 @@ import (
"time" "time"
) )
func (lgr *ConsoleLoggerimpl) init() { func (lgr *ConsoleLoggerImpl) init() {
lgr.messages = make(chan string, logbuffersize) lgr.messages = make(chan string, logbuffersize)
} }
func (logger *ConsoleLoggerimpl) StartLogger() { func (logger *ConsoleLoggerImpl) StartLogger() {
fmt.Println("Starting Logger") fmt.Println("Starting Logger")
loggerlogonce.Do(func() { loggerlogonce.Do(func() {
for msg := range logger.messages { for msg := range logger.messages {
@@ -18,15 +18,15 @@ func (logger *ConsoleLoggerimpl) StartLogger() {
}) })
} }
func (logger *ConsoleLoggerimpl) Write(message string) { func (logger *ConsoleLoggerImpl) Write(message string) {
logger.messages <- time.Now().Format(time.UnixDate) + " : " + message + "\n" logger.messages <- time.Now().Format(time.UnixDate) + " : " + message + "\n"
} }
func (logger *ConsoleLoggerimpl) Write_Request(message string, uuid string) { func (logger *ConsoleLoggerImpl) WriteRequest(message string, uuid string) {
logger.Write(uuid + " : " + message) logger.Write(uuid + " : " + message)
} }
func (logger *ConsoleLoggerimpl) WriteErr(err error) (errnum int) { func (logger *ConsoleLoggerImpl) WriteErr(err error) (errnum int) {
if err != nil { if err != nil {
logger.Write("Error: " + err.Error()) logger.Write("Error: " + err.Error())
errnum = 1 errnum = 1
@@ -34,7 +34,7 @@ func (logger *ConsoleLoggerimpl) WriteErr(err error) (errnum int) {
return errnum return errnum
} }
func (logger *ConsoleLoggerimpl) WriteErr_Request(err error, uuid string) (errnum int) { func (logger *ConsoleLoggerImpl) WriteErrRequest(err error, uuid string) (errnum int) {
if err != nil { if err != nil {
logger.Write(uuid + " : Error: " + err.Error()) logger.Write(uuid + " : Error: " + err.Error())
errnum = 1 errnum = 1
@@ -42,29 +42,29 @@ func (logger *ConsoleLoggerimpl) WriteErr_Request(err error, uuid string) (errnu
return errnum return errnum
} }
func (logger *ConsoleLoggerimpl) Write_DEBUG(message string) { func (logger *ConsoleLoggerImpl) WriteDebug(message string) {
if DEBUG { if DEBUG {
logger.Write(message) logger.Write(message)
} }
} }
func (logger *ConsoleLoggerimpl) Write_Request_DEBUG(message string, uuid string) { func (logger *ConsoleLoggerImpl) WriteRequestDebug(message string, uuid string) {
if DEBUG { if DEBUG {
logger.Write_Request(message, uuid) logger.WriteRequest(message, uuid)
} }
} }
func (logger *ConsoleLoggerimpl) WriteErr_DEBUG(err error) (errnum int) { func (logger *ConsoleLoggerImpl) WriteErrDebug(err error) (errnum int) {
if err != nil { if err != nil {
logger.Write_DEBUG("Error: " + err.Error()) logger.WriteDebug("Error: " + err.Error())
errnum = 1 errnum = 1
} }
return errnum return errnum
} }
func (logger *ConsoleLoggerimpl) WriteErr_Request_DEBUG(err error, uuid string) (errnum int) { func (logger *ConsoleLoggerImpl) WriteErrRequestDebug(err error, uuid string) (errnum int) {
if err != nil { if err != nil {
logger.Write_DEBUG(uuid + " : Error: " + err.Error()) logger.WriteDebug(uuid + " : Error: " + err.Error())
errnum = 1 errnum = 1
} }
return errnum return errnum

30
logger/FileLogger.go
View File

@@ -7,7 +7,7 @@ import (
"time" "time"
) )
func (lgr *FileLoggerimpl) init() { func (lgr *FileLoggerImpl) init() {
lgr.filepath = "./log" lgr.filepath = "./log"
lgr.messages = make(chan string, logbuffersize) lgr.messages = make(chan string, logbuffersize)
envfp, envexist := os.LookupEnv("LOGFILE_GO_LOGGER") envfp, envexist := os.LookupEnv("LOGFILE_GO_LOGGER")
@@ -15,10 +15,10 @@ func (lgr *FileLoggerimpl) init() {
if len(envfp) > 0 { if len(envfp) > 0 {
lgr.filepath = envfp lgr.filepath = envfp
} else { } else {
Logger().Write_DEBUG(fmt.Sprintf("LOGFILE_GO_LOGGER env exist but has an empty value using default value: %s !\n", lgr.filepath)) LoggerInstance().WriteDebug(fmt.Sprintf("LOGFILE_GO_LOGGER env exist but has an empty value using default value: %s !\n", lgr.filepath))
} }
} else { } else {
Logger().Write_DEBUG(fmt.Sprintf("LOGFILE_GO_LOGGER env doesn't exist using default value: %s !\n", lgr.filepath)) LoggerInstance().WriteDebug(fmt.Sprintf("LOGFILE_GO_LOGGER env doesn't exist using default value: %s !\n", lgr.filepath))
} }
f, err := os.OpenFile(lgr.filepath, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660) f, err := os.OpenFile(lgr.filepath, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660)
if err != nil { if err != nil {
@@ -29,7 +29,7 @@ func (lgr *FileLoggerimpl) init() {
lgr.mutex = &sync.Mutex{} lgr.mutex = &sync.Mutex{}
} }
func (logger *FileLoggerimpl) StartLogger() { func (logger *FileLoggerImpl) StartLogger() {
fmt.Println("Starting FileLogger") fmt.Println("Starting FileLogger")
loggerlogonce.Do(func() { loggerlogonce.Do(func() {
for msg := range logger.messages { for msg := range logger.messages {
@@ -58,15 +58,15 @@ func (logger *FileLoggerimpl) StartLogger() {
// logger.mutex.Unlock() // logger.mutex.Unlock()
} }
func (logger *FileLoggerimpl) Write(message string) { func (logger *FileLoggerImpl) Write(message string) {
logger.messages <- time.Now().Format(time.UnixDate) + " : " + message + "\n" logger.messages <- time.Now().Format(time.UnixDate) + " : " + message + "\n"
} }
func (logger *FileLoggerimpl) Write_Request(message string, request string) { func (logger *FileLoggerImpl) WriteRequest(message string, request string) {
logger.Write(request + " : " + message) logger.Write(request + " : " + message)
} }
func (logger *FileLoggerimpl) WriteErr(err error) (errnum int) { func (logger *FileLoggerImpl) WriteErr(err error) (errnum int) {
if err != nil { if err != nil {
logger.Write("Error: " + err.Error()) logger.Write("Error: " + err.Error())
errnum = 1 errnum = 1
@@ -74,7 +74,7 @@ func (logger *FileLoggerimpl) WriteErr(err error) (errnum int) {
return errnum return errnum
} }
func (logger *FileLoggerimpl) WriteErr_Request(err error, uuid string) (errnum int) { func (logger *FileLoggerImpl) WriteErrRequest(err error, uuid string) (errnum int) {
if err != nil { if err != nil {
logger.Write(uuid + " : Error: " + err.Error()) logger.Write(uuid + " : Error: " + err.Error())
errnum = 1 errnum = 1
@@ -82,29 +82,29 @@ func (logger *FileLoggerimpl) WriteErr_Request(err error, uuid string) (errnum i
return errnum return errnum
} }
func (logger *FileLoggerimpl) Write_DEBUG(message string) { func (logger *FileLoggerImpl) WriteDebug(message string) {
if DEBUG { if DEBUG {
logger.Write(message) logger.Write(message)
} }
} }
func (logger *FileLoggerimpl) Write_Request_DEBUG(message string, uuid string) { func (logger *FileLoggerImpl) WriteRequestDebug(message string, uuid string) {
if DEBUG { if DEBUG {
logger.Write_Request(message, uuid) logger.WriteRequest(message, uuid)
} }
} }
func (logger *FileLoggerimpl) WriteErr_DEBUG(err error) (errnum int) { func (logger *FileLoggerImpl) WriteErrDebug(err error) (errnum int) {
if err != nil { if err != nil {
logger.Write_DEBUG("Error: " + err.Error()) logger.WriteDebug("Error: " + err.Error())
errnum = 1 errnum = 1
} }
return errnum return errnum
} }
func (logger *FileLoggerimpl) WriteErr_Request_DEBUG(err error, uuid string) (errnum int) { func (logger *FileLoggerImpl) WriteErrRequestDebug(err error, uuid string) (errnum int) {
if err != nil { if err != nil {
logger.Write_DEBUG(uuid + " : Error: " + err.Error()) logger.WriteDebug(uuid + " : Error: " + err.Error())
errnum = 1 errnum = 1
} }
return errnum return errnum

8
logger/Logger.go
View File

@@ -14,19 +14,19 @@ const logbuffersize int32 = 200
var DEBUG bool = true var DEBUG bool = true
var ( var (
loggerInstance LGRImpl loggerInstance Logger
loggeronce sync.Once loggeronce sync.Once
loggerlogonce sync.Once loggerlogonce sync.Once
) )
func Create(instance LGRImpl) { func Create(instance Logger) {
loggeronce.Do(func() { loggeronce.Do(func() {
loggerInstance = instance loggerInstance = instance
loggerInstance.init() loggerInstance.init()
}) })
} }
func Logger() LGRImpl { func LoggerInstance() Logger {
return loggerInstance return loggerInstance
} }
@@ -42,7 +42,7 @@ func PrintJson[T any](entity *T) string {
func ExampleLogMiddleware(next http.Handler) http.Handler { func ExampleLogMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
Logger().Write_DEBUG(fmt.Sprintf("\tRequest from: %s to: Host: %s URL: %s \tWith HEADERS: %s \tWith BODY: %s", r.RemoteAddr, r.Host, r.URL, r.Header, r.Body)) LoggerInstance().WriteDebug(fmt.Sprintf("\tRequest from: %s to: Host: %s URL: %s \tWith HEADERS: %s \tWith BODY: %s", r.RemoteAddr, r.Host, r.URL, r.Header, r.Body))
next.ServeHTTP(w, r) next.ServeHTTP(w, r)
}) })
} }

20
logger/NullLogger.go
View File

@@ -1,39 +1,39 @@
package logger package logger
func (lgr *NullLoggerimpl) init() {} func (lgr *NullLoggerImpl) init() {}
func (logger *NullLoggerimpl) StartLogger() {} func (logger *NullLoggerImpl) StartLogger() {}
func (logger *NullLoggerimpl) Write(message string) {} func (logger *NullLoggerImpl) Write(message string) {}
func (logger *NullLoggerimpl) Write_Request(message string, request string) {} func (logger *NullLoggerImpl) WriteRequest(message string, request string) {}
func (logger *NullLoggerimpl) WriteErr(err error) (errnum int) { func (logger *NullLoggerImpl) WriteErr(err error) (errnum int) {
if err != nil { if err != nil {
errnum = 1 errnum = 1
} }
return errnum return errnum
} }
func (logger *NullLoggerimpl) WriteErr_Request(err error, request string) (errnum int) { func (logger *NullLoggerImpl) WriteErrRequest(err error, request string) (errnum int) {
if err != nil { if err != nil {
errnum = 1 errnum = 1
} }
return errnum return errnum
} }
func (logger *NullLoggerimpl) Write_DEBUG(message string) {} func (logger *NullLoggerImpl) WriteDebug(message string) {}
func (logger *NullLoggerimpl) Write_Request_DEBUG(message string, uuid string) {} func (logger *NullLoggerImpl) WriteRequestDebug(message string, uuid string) {}
func (logger *NullLoggerimpl) WriteErr_DEBUG(err error) (errnum int) { func (logger *NullLoggerImpl) WriteErrDebug(err error) (errnum int) {
if err != nil { if err != nil {
errnum = 1 errnum = 1
} }
return errnum return errnum
} }
func (logger *NullLoggerimpl) WriteErr_Request_DEBUG(err error, uuid string) (errnum int) { func (logger *NullLoggerImpl) WriteErrRequestDebug(err error, uuid string) (errnum int) {
if err != nil { if err != nil {
errnum = 1 errnum = 1
} }

28
logger/interfaces.go
View File

@@ -9,39 +9,39 @@ package logger
// Unixdate : uuid : message\n // Unixdate : uuid : message\n
// //
// Unixdate : uuid : Error: error\n // Unixdate : uuid : Error: error\n
type LGRImpl interface { type Logger interface {
LoggerI ReleaseLogger
DebugLoggerI DebugLogger
} }
type ( type (
LoggerI interface { ReleaseLogger interface {
// Private, use it for member initialization etc // Private, use it for member initialization etc
init() init()
// Start an infinite loop to write out messages from the channel // Start an infinite loop to write out messages from the channel
StartLogger() StartLogger()
Write(message string) Write(message string)
Write_Request(message string, uuid string) WriteRequest(message string, uuid string)
// If an error that is not nill passed in it logs the error and returns 1, otherwise 0 // If an error that is not nill passed in it logs the error and returns 1, otherwise 0
WriteErr(error) int WriteErr(error) int
WriteErr_Request(err error, uuid string) int WriteErrRequest(err error, uuid string) int
} }
// Use _DEBUG prints to strip them out of release builds // Use _DEBUG prints to strip them out of release builds
DebugLoggerI interface { DebugLogger interface {
// Private, use it for member initialization etc // Private, use it for member initialization etc
init() init()
// Start an infinite loop to write out messages from the channel // Start an infinite loop to write out messages from the channel
StartLogger() StartLogger()
Write_DEBUG(message string) WriteDebug(message string)
Write_Request_DEBUG(message string, uuid string) WriteRequestDebug(message string, uuid string)
WriteErr_DEBUG(err error) (errnum int) WriteErrDebug(err error) (errnum int)
WriteErr_Request_DEBUG(err error, uuid string) int WriteErrRequestDebug(err error, uuid string) int
} }
) )
// Ensure all methods from LGRImpl are implemented ccompile time // Ensure all methods from LGRImpl are implemented ccompile time
var ( var (
_ LGRImpl = (*NullLoggerimpl)(nil) _ Logger = (*NullLoggerImpl)(nil)
_ LGRImpl = (*ConsoleLoggerimpl)(nil) _ Logger = (*ConsoleLoggerImpl)(nil)
_ LGRImpl = (*FileLoggerimpl)(nil) _ Logger = (*FileLoggerImpl)(nil)
) )

6
logger/types.go
View File

@@ -6,14 +6,14 @@ import (
) )
// A logger without logging functionality // A logger without logging functionality
type NullLoggerimpl struct{} type NullLoggerImpl struct{}
// A logger that logs to sdtout // A logger that logs to sdtout
type ConsoleLoggerimpl struct { type ConsoleLoggerImpl struct {
messages chan string messages chan string
} }
type FileLoggerimpl struct { type FileLoggerImpl struct {
messages chan string messages chan string
mutex *sync.Mutex mutex *sync.Mutex
logFile *os.File logFile *os.File

34
main_test.go
View File

@@ -11,26 +11,26 @@ import (
) )
func TestTypes(t *testing.T) { func TestTypes(t *testing.T) {
Create(&FileLoggerimpl{}) Create(&FileLoggerImpl{})
go Logger().StartLogger() go LoggerInstance().StartLogger()
Logger().Write("TEST MSG") LoggerInstance().Write("TEST MSG")
time.Sleep(time.Second * 2) time.Sleep(time.Second * 2)
x := Some("Test") x := Some("Test")
AssertTrue(t, x.Is_some()) AssertTrue(t, x.IsSome())
AssertTrue(t, !x.Is_none()) AssertTrue(t, !x.IsNone())
AssertEqual(t, x.Unwrap(), "Test") AssertEqual(t, x.Unwrap(), "Test")
AssertTrue(t, None_t(1).Is_none()) AssertTrue(t, None_t(1).IsNone())
err := errors.New("Test") err := errors.New("Test")
y := Err_t(err, "t") y := Err_t(err, "t")
AssertEqual(t, y.Unwrap_err(), err) AssertEqual(t, y.UnwrapErr(), err)
AssertError(t, y.Unwrap_err()) AssertError(t, y.UnwrapErr())
z := x.Ok_or(err) z := x.OkOr(err)
AssertTrue(t, z.Is_ok()) AssertTrue(t, z.IsOk())
AssertEqual(t, None[string]().Ok_or(err).Unwrap_err(), err) AssertEqual(t, None[string]().OkOr(err).UnwrapErr(), err)
AssertTrue(t, Has_value(x)) AssertTrue(t, HasValue(x))
AssertTrue(t, Has_value(y.Err())) AssertTrue(t, HasValue(y.Err()))
AssertTrue(t, Has_value(y.Err().Ok_or(err))) AssertTrue(t, HasValue(y.Err().OkOr(err)))
AssertEqual(t, err, y.Err().Ok_or(err).Unwrap()) AssertEqual(t, err, y.Err().OkOr(err).Unwrap())
AssertEqual(t, err, y.Err().Ok_or(errors.New("")).Unwrap()) AssertEqual(t, err, y.Err().OkOr(errors.New("")).Unwrap())
AssertNotEqual(t, err, Err[string](errors.New("asd")).Unwrap_err()) AssertNotEqual(t, err, Err[string](errors.New("asd")).UnwrapErr())
} }

44
typeutils/interfaces.go
View File

@@ -2,34 +2,34 @@ package typeutils
// Created to abstract over Is_some and Is_ok // Created to abstract over Is_some and Is_ok
type ValueContainer interface { type ValueContainer interface {
Has_value() bool HasValue() bool
} }
type Unwrappable[T any] interface { type Unwrappable[T any] interface {
Expect(string) T // panics with a provided custom message Expect(string) T // panics with a provided custom message
Unwrap() T // panics with a generic message Unwrap() T // panics with a generic message
Unwrap_or(T) T // returns the provided default value UnwrapOr(T) T // returns the provided default value
Unwrap_or_default() T // returns the default value of the type T UnwrapOrDefault() T // returns the default value of the type T
Unwrap_or_else(func() T) T // returns the result of evaluating the provided function UnwrapOrElse(func() T) T // returns the result of evaluating the provided function
} }
// Both an Optional and Result is an Option // Both an Optional and Result is an Optioner
type Option[T any] interface { type Optioner[T any] interface {
ValueContainer ValueContainer
Unwrappable[T] Unwrappable[T]
} }
type OptionalI[T any] interface { type Optionaler[T any] interface {
Is_some() bool IsSome() bool
Is_none() bool IsNone() bool
Ok_or(error) Result[T] OkOr(error) Result[T]
Ok_or_else(func() error) Result[T] OkOrElse(func() error) Result[T]
Unwrappable[T] Unwrappable[T]
} }
type ResultI[T any] interface { type Resulter[T any] interface {
Is_ok() bool IsOk() bool
Is_err() bool IsErr() bool
Ok() Optional[T] Ok() Optional[T]
Err() Optional[error] Err() Optional[error]
Unwrappable[T] Unwrappable[T]
@@ -37,10 +37,10 @@ type ResultI[T any] interface {
// Ensure compile time the interfaces are implemented // Ensure compile time the interfaces are implemented
var ( var (
_ Option[any] = (*Optional[any])(nil) _ Optioner[any] = (*Optional[any])(nil)
_ Option[any] = (*Result[any])(nil) _ Optioner[any] = (*Result[any])(nil)
_ OptionalI[any] = (*Optional[any])(nil) _ Optionaler[any] = (*Optional[any])(nil)
_ ResultI[any] = (*Result[any])(nil) _ Resulter[any] = (*Result[any])(nil)
_ ValueContainer = (*Optional[any])(nil) _ ValueContainer = (*Optional[any])(nil)
_ ValueContainer = (*Result[any])(nil) _ ValueContainer = (*Result[any])(nil)
) )

16
typeutils/optional.go
View File

@@ -16,10 +16,10 @@ func None_t[T any](T) Optional[T] {
// CTORS END // CTORS END
func (opt Optional[T]) Is_some() bool { return opt.present } func (opt Optional[T]) IsSome() bool { return opt.present }
func (opt Optional[T]) Is_none() bool { return !opt.present } func (opt Optional[T]) IsNone() bool { return !opt.present }
func (opt Optional[T]) Has_value() bool { return opt.Is_some() } func (opt Optional[T]) HasValue() bool { return opt.IsSome() }
// UNWRAPPABLE INTERFACE BEGIN // UNWRAPPABLE INTERFACE BEGIN
func (opt Optional[T]) Expect(msg string) T { func (opt Optional[T]) Expect(msg string) T {
@@ -36,14 +36,14 @@ func (opt Optional[T]) Unwrap() T {
panic("Tried unwrapping an Optional that did not have a value!") panic("Tried unwrapping an Optional that did not have a value!")
} }
func (opt Optional[T]) Unwrap_or(val T) T { func (opt Optional[T]) UnwrapOr(val T) T {
if opt.present { if opt.present {
return opt.value return opt.value
} }
return val return val
} }
func (opt Optional[T]) Unwrap_or_default() T { func (opt Optional[T]) UnwrapOrDefault() T {
if opt.present { if opt.present {
return opt.value return opt.value
} }
@@ -51,7 +51,7 @@ func (opt Optional[T]) Unwrap_or_default() T {
return res return res
} }
func (opt Optional[T]) Unwrap_or_else(f func() T) T { func (opt Optional[T]) UnwrapOrElse(f func() T) T {
if opt.present { if opt.present {
return opt.value return opt.value
} }
@@ -61,7 +61,7 @@ func (opt Optional[T]) Unwrap_or_else(f func() T) T {
// UNWRAPPABLE INTERFACE END // UNWRAPPABLE INTERFACE END
// transforms Some(v) to Ok(v), and None to Err(err) // transforms Some(v) to Ok(v), and None to Err(err)
func (opt Optional[T]) Ok_or(err error) Result[T] { func (opt Optional[T]) OkOr(err error) Result[T] {
if opt.present { if opt.present {
return Ok(opt.value) return Ok(opt.value)
} }
@@ -69,7 +69,7 @@ func (opt Optional[T]) Ok_or(err error) Result[T] {
} }
// transforms Some(v) to Ok(v), and None to a value of Err using the provided function // transforms Some(v) to Ok(v), and None to a value of Err using the provided function
func (opt Optional[T]) Ok_or_else(f func() error) Result[T] { func (opt Optional[T]) OkOrElse(f func() error) Result[T] {
if opt.present { if opt.present {
return Ok(opt.value) return Ok(opt.value)
} }

16
typeutils/result.go
View File

@@ -15,10 +15,10 @@ func Err_t[T any](err error, x T) Result[T] {
// CTORS END // CTORS END
func (res Result[T]) Is_ok() bool { return res.err == nil } func (res Result[T]) IsOk() bool { return res.err == nil }
func (res Result[T]) Is_err() bool { return res.err != nil } func (res Result[T]) IsErr() bool { return res.err != nil }
func (res Result[T]) Has_value() bool { return res.Is_ok() } func (res Result[T]) HasValue() bool { return res.IsOk() }
// UNWRAPPABLE INTERFACE // UNWRAPPABLE INTERFACE
func (res Result[T]) Expect(msg string) T { func (res Result[T]) Expect(msg string) T {
@@ -35,14 +35,14 @@ func (res Result[T]) Unwrap() T {
panic("Tried unwrapping a Result that had an error value!") panic("Tried unwrapping a Result that had an error value!")
} }
func (res Result[T]) Unwrap_or(val T) T { func (res Result[T]) UnwrapOr(val T) T {
if res.err == nil { if res.err == nil {
return res.value return res.value
} }
return val return val
} }
func (res Result[T]) Unwrap_or_default() T { func (res Result[T]) UnwrapOrDefault() T {
if res.err == nil { if res.err == nil {
return res.value return res.value
} }
@@ -50,7 +50,7 @@ func (res Result[T]) Unwrap_or_default() T {
return ret return ret
} }
func (res Result[T]) Unwrap_or_else(f func() T) T { func (res Result[T]) UnwrapOrElse(f func() T) T {
if res.err == nil { if res.err == nil {
return res.value return res.value
} }
@@ -60,7 +60,7 @@ func (res Result[T]) Unwrap_or_else(f func() T) T {
// UNWRAPPABLE INTERFACE // UNWRAPPABLE INTERFACE
// This function panic on Ok instead of Err // This function panic on Ok instead of Err
func (res Result[T]) Expect_err(msg string) error { func (res Result[T]) ExpectErr(msg string) error {
if res.err != nil { if res.err != nil {
return res.err return res.err
} }
@@ -68,7 +68,7 @@ func (res Result[T]) Expect_err(msg string) error {
} }
// This function panic on Ok instead of Err // This function panic on Ok instead of Err
func (res Result[T]) Unwrap_err() error { func (res Result[T]) UnwrapErr() error {
if res.err != nil { if res.err != nil {
return res.err return res.err
} }

16
typeutils/utils.go
View File

@@ -8,21 +8,21 @@ func Unwrap[T any](val Unwrappable[T]) T {
return val.Unwrap() return val.Unwrap()
} }
func Unwrap_or[T any](val Unwrappable[T]) (def T) { func UnwrapOr[T any](val Unwrappable[T]) (def T) {
return val.Unwrap_or(def) return val.UnwrapOr(def)
} }
func Unwrap_or_default[T any](val Unwrappable[T]) T { func UnwrapOrDefault[T any](val Unwrappable[T]) T {
return val.Unwrap_or_default() return val.UnwrapOrDefault()
} }
func Unwrap_or_else[T any](val Unwrappable[T], f func() T) T { func UnwrapOrElse[T any](val Unwrappable[T], f func() T) T {
return val.Unwrap_or_else(f) return val.UnwrapOrElse(f)
} }
// Returns if the underlying data has a Value (false in case of None or Error) // Returns if the underlying data has a Value (false in case of None or Error)
func Has_value(val ValueContainer) bool { func HasValue(val ValueContainer) bool {
return val.Has_value() return val.HasValue()
} }
func ResultWrap[T any](val T, err error) Result[T] { func ResultWrap[T any](val T, err error) Result[T] {