Typ is a library providing a powerful interface to impressive user experience with conversion and fetching data from built-in types in Golang
- Safe conversion along built-in types like as
bool
,int
,int8
,int16
,int32
,int64
,uint
,uint8
,uint16
,uint32
,uint64
,float32
,float64
,complex64
,complex128
,string
- Null types for all primitive types with supported interfaces:
json.Unmarshaler
,json.Marshaler
,sql.Scanner
,driver.Valuer
- Value retriever for multidimensional unstructured data from interface
- Conversion functions present via interface (reflection) and native types for better performance
- Some humanize string conversion functions
Use go get
to install the latest version of the library.
go get -u github.com/gurukami/typ
Then include package in your application and enjoy.
import "github.com/gurukami/typ/v2"
Of(interface{}) conversion from interface value to built-in type
// typ.Of(v interface{}, options ...Option).{Type}(defaultValue ...{Type})
//
// Where {Type} any of
// Bool,
// Int, Int8, Int16, Int32, Int64,
// Uint, Uint8, Uint16, Uint32, Uint64,
// Float32, Float,
// Complex64, Complex,
// String
//
// All methods for conversion returns {Type}Accessor with helpful methods
//
// V() - value of type
// Present() - determines whether a value has been set
// Valid() - determines whether a value has been valid (without error)
// Err() error - returns underlying error
// Set(value {Type}) - saves value into current struct
// Clone() {Type}Accessor - returns new instance of current struct with preserved value & error
//
// Scan(value interface{}) | sql.Scanner
// Value() (driver.Value, error) | driver.Valuer
//
// UnmarshalJSON(b []byte) error | json.Unmarshaler
// MarshalJSON() ([]byte, error) | json.Marshaler
// Valid
nv := typ.Of(3.1415926535, typ.FmtByte('g'), typ.Precision(4)).String()
fmt.Printf("Value: %v, Valid: %v, Present: %v, Error: %v\n", nv.V(), nv.Valid(), nv.Present(), nv.Error)
// Output: Value: 3.142, Valid: true, Present: true, Error: <nil>
// Not valid
nv = typ.Of(3.1415926535).Int()
fmt.Printf("Value: %v, Valid: %v, Present: %v, Error: %v\n", nv.V(), nv.Valid(), nv.Present(), nv.Error)
// Output: Value: 3, Valid: false, Present: true, Error: value can't safely convert
Native conversion without reflection
when type is know
// For the best performance always use this way if you know about exact type
//
// typ.{FromType}{ToType}(value , [options ...{FromType}{ToType}Option]).V()
//
// Where {FromType}, {ToType} any of
// Bool,
// Int, Int8, Int16, Int32, Int64,
// Uint, Uint8, Uint16, Uint32, Uint64,
// Float32, Float,
// Complex64, Complex,
// String
//
// All methods for conversion returns {Type}Accessor interface with helpful methods & fields, additional info you can read in example above
// Valid
nv := typ.FloatString(3.1415926535, typ.FloatStringFmtByte('g'), typ.FloatStringPrecision(4))
fmt.Printf("Value: %v, Valid: %v, Present: %v, Error: %v\n", nv.V(), nv.Valid(), nv.Present(), nv.Error)
// Output: Value: 3.142, Valid: true, Present: true, Error: <nil>
// Not valid
nv = typ.FloatInt(3.1415926535)
fmt.Printf("Value: %v, Valid: %v, Present: %v, Error: %v\n", nv.V(), nv.Valid(), nv.Present(), nv.Error)
// Output: Value: 3, Valid: false, Present: true, Error: value can't safely convert
Retrieve multidimensional unstructured data from interface
data := map[int]interface{}{
0: []interface{}{
0: map[string]int{
"0": 42,
},
},
}
// Instead of do something like this
// data[0].([]interface{})[0].(map[string]int)["0”]
// and not caught a panic
// use this
// Value exists
nv := typ.Of(data).Get(0, 0, "0").Interface()
fmt.Printf("Value: %v, Valid: %v, Present: %v, Error: %v\n", nv.V(), nv.Valid(), nv.Present(), nv.Error)
// Output: Value: 42, Valid: true, Present: true, Error: <nil>
// Value not exists
nv = typ.Of(data).Get(3, 7, "5").Interface()
fmt.Printf("Value: %v, Valid: %v, Present: %v, Error: %v\n", nv.V(), nv.Valid(), nv.Present(), nv.Error)
// Output: Value: <nil>, Valid: false, Present: false, Error: out of bounds on given data
Rules of safely type conversion along types
From / to | Bool | Int* | String | Uint* | Float* | Complex* |
---|---|---|---|---|---|---|
Bool | + | + | + | + | + | + |
Int* | + | + | formatting |
>= 0 |
24bit or 53bit |
real , 24bit or 53bit |
String | parsing |
parsing |
+ | parsing |
parsing |
parsing |
Uint* | + | 63bit |
formatting |
+ | 24bit or 53bit |
24bit or 53bit |
Float* | + | 24bit or 53bit |
formatting |
>= 0 , 24bit or 53bit |
+ | + |
Complex* | + | real , 24bit or 53bit |
+ | >= 0 , real , 24bit or 53bit |
real |
+ |
* based on bit size capacity, 8,16,32,64
for Int
,Uint
; 32,64
for Float
,Complex
I like airplanes and i want to get private pilot licence, and i believe you can help me to make my dream come true :)
>>>>>>>>>> Make a dream come true <<<<<<<<<<
The MIT license
Copyright (c) 2019 Gurukami