https://github.com/gurukami/typ

Null Types, Safe primitive type conversion and fetching value from complex structures.
https://github.com/gurukami/typ

cast go golang golang-library typecast types

Last synced: about 2 months ago
JSON representation

Null Types, Safe primitive type conversion and fetching value from complex structures.

• Host: GitHub
• URL: https://github.com/gurukami/typ
• Owner: gurukami
• License: mit
• Created: 2019-03-03T05:34:23.000Z (almost 6 years ago)
• Default Branch: master
• Last Pushed: 2021-10-15T16:11:56.000Z (about 3 years ago)
• Last Synced: 2024-07-31T20:48:19.667Z (4 months ago)
• Topics: cast, go, golang, golang-library, typecast, types
• Language: Go
• Homepage:
• Size: 98.6 KB
• Stars: 46
• Watchers: 3
• Forks: 4
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

• awesome-go - typ - Null Types, Safe primitive type conversion and fetching value from complex structures. (Data Structures and Algorithms / Nullable Types)
• awesome-go - typ - Null Types, Safe primitive type conversion and fetching value from complex structures. (Data Structures and Algorithms / Nullable Types)
• awesome-go-extra - typ - 03-03T05:34:23Z|2021-10-15T16:11:56Z| (Generators / Nullable Types)

README

        
# Typ

[![GoDoc](https://godoc.org/github.com/gurukami/typ?status.svg)](https://godoc.org/github.com/gurukami/typ)

[![Build Status](https://travis-ci.org/gurukami/typ.svg "Travis CI status")](https://travis-ci.org/gurukami/typ)

[![Coverage Status](https://img.shields.io/codecov/c/github/gurukami/typ/master.svg)](https://codecov.io/github/gurukami/typ?branch=master)

[![Go Report Card](https://goreportcard.com/badge/github.com/gurukami/typ?style=flat)](https://goreportcard.com/report/github.com/gurukami/typ)

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

Typ is a library providing a powerful interface to impressive user experience with conversion and fetching data from built-in types in Golang

## Features

* 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

## Installation

Use ```go get``` to install the latest version of the library. 

```go

    go get -u github.com/gurukami/typ

```

Then include package in your application and enjoy.

```go

    import "github.com/gurukami/typ/v2"

```

## Usage

**Of(interface{})** conversion from interface value to built-in type

```go

// 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: 

// 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** 

```go

// 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: 

// 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** 

```go

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: 

// 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: , 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`

## Donation for amazing goal

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** <<<<<<<<<< ](https://gist.github.com/Nerufa/0d868899d628b1b105f74b6da501bc1f)

## License

The MIT license  

Copyright (c) 2019 Gurukami