add value vithh error (#1)

Co-authored-by: andrey1s <andrey@4devs.pro>
Reviewed-on: #1
Co-authored-by: andrey <andrey@4devs.io>
Co-committed-by: andrey <andrey@4devs.io>

input/value/any.go

@@ -1,21 +1,137 @@
 package value
 
-import "gitoa.ru/go-4devs/console/input/value/flag"
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+)
 
-type Any struct {
-	empty
-	Val  []interface{}
-	Flag flag.Flag
+var _ Value = NewAny(nil)
+
+//nolint:gochecknoglobals
+var (
+	emptyValue = NewAny(nil)
+)
+
+func Empty() Value {
+	return emptyValue
 }
 
-func (a *Any) Any() interface{} {
-	if a.Flag.IsArray() {
-		return a.Val
+func IsEmpty(v Value) bool {
+	return v == nil || v == emptyValue
+}
+
+func NewAny(in interface{}) Value {
+	return Read{Any{v: in}}
+}
+
+type Any struct {
+	v interface{}
+}
+
+func (a Any) Any() interface{} {
+	return a.v
+}
+
+func (a Any) Unmarshal(val interface{}) error {
+	out, err := a.ParseString()
+	if err != nil {
+		return fmt.Errorf("any parse string:%w", err)
 	}
 
-	if len(a.Val) > 0 {
-		return a.Val[0]
+	uerr := json.Unmarshal([]byte(out), val)
+	if uerr != nil {
+		return fmt.Errorf("any unmarshal: %w", uerr)
 	}
 
 	return nil
 }
+
+func (a Any) ParseString() (string, error) {
+	if a.v == nil {
+		return "", nil
+	}
+
+	bout, err := json.Marshal(a.v)
+	if err != nil {
+		return "", fmt.Errorf("any string:%w", err)
+	}
+
+	return string(bout), err
+}
+
+func (a Any) ParseInt() (int, error) {
+	out, ok := a.v.(int)
+	if !ok {
+		return 0, a.wrongType("int")
+	}
+
+	return out, nil
+}
+
+func (a Any) ParseInt64() (int64, error) {
+	out, ok := a.v.(int64)
+	if !ok {
+		return 0, a.wrongType("int64")
+	}
+
+	return out, nil
+}
+
+func (a Any) ParseUint() (uint, error) {
+	out, ok := a.v.(uint)
+	if !ok {
+		return 0, a.wrongType("uint")
+	}
+
+	return out, nil
+}
+
+func (a Any) ParseUint64() (uint64, error) {
+	out, ok := a.v.(uint64)
+	if !ok {
+		return 0, a.wrongType("uint64")
+	}
+
+	return out, nil
+}
+
+func (a Any) ParseFloat64() (float64, error) {
+	out, ok := a.v.(float64)
+	if !ok {
+		return 0, a.wrongType("float64")
+	}
+
+	return out, nil
+}
+
+func (a Any) ParseBool() (bool, error) {
+	out, ok := a.v.(bool)
+	if !ok {
+		return false, a.wrongType("bool")
+	}
+
+	return out, nil
+}
+
+func (a Any) ParseDuration() (time.Duration, error) {
+	out, ok := a.v.(time.Duration)
+	if !ok {
+		return 0, a.wrongType("time.Duration")
+	}
+
+	return out, nil
+}
+
+func (a Any) ParseTime() (time.Time, error) {
+	out, ok := a.v.(time.Time)
+	if !ok {
+		return time.Time{}, a.wrongType("time.Time")
+	}
+
+	return out, nil
+}
+
+func (a Any) wrongType(ex String) error {
+	return fmt.Errorf("%w any: got: %T expect: %s", ErrWrongType, a.v, ex)
+}

input/value/bool.go

@@ -1,44 +1,148 @@
 package value
 
 import (
-	"strconv"
-
-	"gitoa.ru/go-4devs/console/input/value/flag"
+	"fmt"
+	"time"
 )
 
-type Bool struct {
-	empty
-	Val  []bool
-	Flag flag.Flag
+var (
+	_ ParseValue = Bool(false)
+	_ SliceValue = Bools{}
+)
+
+func NewBools(in []bool) Slice {
+	return Slice{SliceValue: Bools(in)}
 }
 
-func (b *Bool) Append(in string) error {
-	v, err := strconv.ParseBool(in)
-	if err != nil {
-		return err
+type Bools []bool
+
+func (b Bools) Any() interface{} {
+	return b.Bools()
+}
+
+func (b Bools) Unmarshal(val interface{}) error {
+	v, ok := val.(*[]bool)
+	if !ok {
+		return fmt.Errorf("%w: expect: *[]bool got: %T", ErrWrongType, val)
 	}
 
-	b.Val = append(b.Val, v)
+	*v = b
 
 	return nil
 }
 
-func (b *Bool) Bool() bool {
-	if !b.Flag.IsArray() && len(b.Val) == 1 {
-		return b.Val[0]
+func (b Bools) Strings() []string {
+	return nil
+}
+
+func (b Bools) Ints() []int {
+	return nil
+}
+
+func (b Bools) Int64s() []int64 {
+	return nil
+}
+
+func (b Bools) Uints() []uint {
+	return nil
+}
+
+func (b Bools) Uint64s() []uint64 {
+	return nil
+}
+
+func (b Bools) Float64s() []float64 {
+	return nil
+}
+
+func (b Bools) Bools() []bool {
+	out := make([]bool, len(b))
+	copy(out, b)
+
+	return out
+}
+
+func (b Bools) Durations() []time.Duration {
+	return nil
+}
+
+func (b Bools) Times() []time.Time {
+	return nil
+}
+
+func NewBool(in bool) Read {
+	return Read{ParseValue: Bool(in)}
+}
+
+type Bool bool
+
+func (b Bool) Unmarshal(val interface{}) error {
+	v, ok := val.(*bool)
+	if !ok {
+		return fmt.Errorf("%w: expect: *bool got: %T", ErrWrongType, val)
 	}
 
-	return false
+	*v = bool(b)
+
+	return nil
 }
 
-func (b *Bool) Bools() []bool {
-	return b.Val
+func (b Bool) ParseString() (string, error) {
+	return fmt.Sprintf("%v", b), nil
 }
 
-func (b *Bool) Any() interface{} {
-	if b.Flag.IsArray() {
-		return b.Bools()
+func (b Bool) ParseInt() (int, error) {
+	if b {
+		return 1, nil
 	}
 
-	return b.Bool()
+	return 0, nil
+}
+
+func (b Bool) ParseInt64() (int64, error) {
+	if b {
+		return 1, nil
+	}
+
+	return 0, nil
+}
+
+func (b Bool) ParseUint() (uint, error) {
+	if b {
+		return 1, nil
+	}
+
+	return 0, nil
+}
+
+func (b Bool) ParseUint64() (uint64, error) {
+	if b {
+		return 1, nil
+	}
+
+	return 0, nil
+}
+
+func (b Bool) ParseFloat64() (float64, error) {
+	if b {
+		return 1, nil
+	}
+
+	return 0, nil
+}
+
+func (b Bool) ParseBool() (bool, error) {
+	return bool(b), nil
+}
+
+func (b Bool) ParseDuration() (time.Duration, error) {
+	return 0, fmt.Errorf("bool to duration:%w", ErrWrongType)
+}
+
+func (b Bool) ParseTime() (time.Time, error) {
+	return time.Time{}, fmt.Errorf("bool to time:%w", ErrWrongType)
+}
+
+func (b Bool) Any() interface{} {
+	return bool(b)
 }

input/value/duration.go

@@ -1,44 +1,128 @@
 package value
 
 import (
+	"fmt"
 	"time"
-
-	"gitoa.ru/go-4devs/console/input/value/flag"
 )
 
-type Duration struct {
-	empty
-	Val  []time.Duration
-	Flag flag.Flag
+var (
+	_ ParseValue = Duration(0)
+	_ SliceValue = Durations{}
+)
+
+func NewDurations(in []time.Duration) Slice {
+	return Slice{SliceValue: Durations(in)}
 }
 
-func (d *Duration) Append(in string) error {
-	v, err := time.ParseDuration(in)
-	if err != nil {
-		return err
+type Durations []time.Duration
+
+func (d Durations) Unmarshal(val interface{}) error {
+	v, ok := val.(*[]time.Duration)
+	if !ok {
+		return fmt.Errorf("%w: expect: *[]time.Duration got: %T", ErrWrongType, val)
 	}
 
-	d.Val = append(d.Val, v)
+	*v = d
 
 	return nil
 }
 
-func (d *Duration) Duration() time.Duration {
-	if !d.Flag.IsArray() && len(d.Val) == 1 {
-		return d.Val[0]
+func (d Durations) Any() interface{} {
+	return d.Durations()
+}
+
+func (d Durations) Strings() []string {
+	return nil
+}
+
+func (d Durations) Ints() []int {
+	return nil
+}
+
+func (d Durations) Int64s() []int64 {
+	return nil
+}
+
+func (d Durations) Uints() []uint {
+	return nil
+}
+
+func (d Durations) Uint64s() []uint64 {
+	return nil
+}
+
+func (d Durations) Float64s() []float64 {
+	return nil
+}
+
+func (d Durations) Bools() []bool {
+	return nil
+}
+
+func (d Durations) Durations() []time.Duration {
+	out := make([]time.Duration, len(d))
+	copy(out, d)
+
+	return out
+}
+
+func (d Durations) Times() []time.Time {
+	return nil
+}
+
+func NewDuration(in time.Duration) Read {
+	return Read{ParseValue: Duration(in)}
+}
+
+type Duration time.Duration
+
+func (d Duration) ParseDuration() (time.Duration, error) {
+	return time.Duration(d), nil
+}
+
+func (d Duration) ParseString() (string, error) {
+	return time.Duration(d).String(), nil
+}
+
+func (d Duration) ParseInt() (int, error) {
+	return int(d), nil
+}
+
+func (d Duration) ParseInt64() (int64, error) {
+	return int64(d), nil
+}
+
+func (d Duration) ParseUint() (uint, error) {
+	return uint(d), nil
+}
+
+func (d Duration) ParseUint64() (uint64, error) {
+	return uint64(d), nil
+}
+
+func (d Duration) ParseFloat64() (float64, error) {
+	return float64(d), nil
+}
+
+func (d Duration) ParseBool() (bool, error) {
+	return false, fmt.Errorf("duration:%w", ErrWrongType)
+}
+
+func (d Duration) ParseTime() (time.Time, error) {
+	return time.Time{}, fmt.Errorf("duration:%w", ErrWrongType)
+}
+
+func (d Duration) Unmarshal(val interface{}) error {
+	v, ok := val.(*time.Duration)
+	if !ok {
+		return fmt.Errorf("%w: expect: *[]time.Duration got: %T", ErrWrongType, val)
 	}
 
-	return 0
+	*v = time.Duration(d)
+
+	return nil
 }
 
-func (d *Duration) Durations() []time.Duration {
-	return d.Val
-}
-
-func (d *Duration) Any() interface{} {
-	if d.Flag.IsArray() {
-		return d.Durations()
-	}
-
-	return d.Duration()
+func (d Duration) Any() interface{} {
+	return time.Duration(d)
 }

input/value/empty.go

@@ -1,100 +0,0 @@
-package value
-
-import (
-	"time"
-)
-
-// nolint: gochecknoglobals
-var (
-	emptyValue = &empty{}
-)
-
-func Empty() Value {
-	return emptyValue
-}
-
-func IsEmpty(v Value) bool {
-	return v == nil || v == emptyValue
-}
-
-type empty struct{}
-
-func (e *empty) Append(string) error {
-	return ErrAppendEmpty
-}
-
-func (e *empty) String() string {
-	return ""
-}
-
-func (e *empty) Int() int {
-	return 0
-}
-
-func (e *empty) Int64() int64 {
-	return 0
-}
-
-func (e *empty) Uint() uint {
-	return 0
-}
-
-func (e *empty) Uint64() uint64 {
-	return 0
-}
-
-func (e *empty) Float64() float64 {
-	return 0
-}
-
-func (e *empty) Bool() bool {
-	return false
-}
-
-func (e *empty) Duration() time.Duration {
-	return 0
-}
-
-func (e *empty) Time() time.Time {
-	return time.Time{}
-}
-
-func (e *empty) Strings() []string {
-	return nil
-}
-
-func (e *empty) Ints() []int {
-	return nil
-}
-
-func (e *empty) Int64s() []int64 {
-	return nil
-}
-
-func (e *empty) Uints() []uint {
-	return nil
-}
-
-func (e *empty) Uint64s() []uint64 {
-	return nil
-}
-
-func (e *empty) Float64s() []float64 {
-	return nil
-}
-
-func (e *empty) Bools() []bool {
-	return nil
-}
-
-func (e *empty) Durations() []time.Duration {
-	return nil
-}
-
-func (e *empty) Times() []time.Time {
-	return nil
-}
-
-func (e *empty) Any() interface{} {
-	return nil
-}

input/value/flag/flag.go

@@ -1,97 +0,0 @@
-package flag
-
-//go:generate stringer -type=Flag -linecomment
-
-type Flag int
-
-const (
-	String   Flag = 0         // string
-	Required Flag = 1 << iota // required
-	Array                     // array
-	Int                       // int
-	Int64                     // int64
-	Uint                      // uint
-	Uint64                    // uint64
-	Float64                   // float64
-	Bool                      // bool
-	Duration                  // duration
-	Time                      // time
-	Any                       // any
-)
-
-func (i Flag) With(v Flag) Flag {
-	return i | v
-}
-
-func (i Flag) IsString() bool {
-	return i|Required|Array^Required^Array == 0
-}
-
-func (i Flag) IsRequired() bool {
-	return i&Required > 0
-}
-
-func (i Flag) IsArray() bool {
-	return i&Array > 0
-}
-
-func (i Flag) IsInt() bool {
-	return i&Int > 0
-}
-
-func (i Flag) IsInt64() bool {
-	return i&Int64 > 0
-}
-
-func (i Flag) IsUint() bool {
-	return i&Uint > 0
-}
-
-func (i Flag) IsUint64() bool {
-	return i&Uint64 > 0
-}
-
-func (i Flag) IsFloat64() bool {
-	return i&Float64 > 0
-}
-
-func (i Flag) IsBool() bool {
-	return i&Bool > 0
-}
-
-func (i Flag) IsDuration() bool {
-	return i&Duration > 0
-}
-
-func (i Flag) IsTime() bool {
-	return i&Time > 0
-}
-
-func (i Flag) IsAny() bool {
-	return i&Any > 0
-}
-
-func (i Flag) Type() Flag {
-	switch {
-	case i.IsInt():
-		return Int
-	case i.IsInt64():
-		return Int64
-	case i.IsUint():
-		return Uint
-	case i.IsUint64():
-		return Uint64
-	case i.IsFloat64():
-		return Float64
-	case i.IsBool():
-		return Bool
-	case i.IsDuration():
-		return Duration
-	case i.IsTime():
-		return Time
-	case i.IsAny():
-		return Any
-	default:
-		return String
-	}
-}

input/value/flag/flag_string.go

@@ -1,47 +0,0 @@
-// Code generated by "stringer -type=Flag -linecomment"; DO NOT EDIT.
-
-package flag
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[String-0]
-	_ = x[Required-2]
-	_ = x[Array-4]
-	_ = x[Int-8]
-	_ = x[Int64-16]
-	_ = x[Uint-32]
-	_ = x[Uint64-64]
-	_ = x[Float64-128]
-	_ = x[Bool-256]
-	_ = x[Duration-512]
-	_ = x[Time-1024]
-	_ = x[Any-2048]
-}
-
-const _Flag_name = "stringrequiredarrayintint64uintuint64float64booldurationtimeany"
-
-var _Flag_map = map[Flag]string{
-	0:    _Flag_name[0:6],
-	2:    _Flag_name[6:14],
-	4:    _Flag_name[14:19],
-	8:    _Flag_name[19:22],
-	16:   _Flag_name[22:27],
-	32:   _Flag_name[27:31],
-	64:   _Flag_name[31:37],
-	128:  _Flag_name[37:44],
-	256:  _Flag_name[44:48],
-	512:  _Flag_name[48:56],
-	1024: _Flag_name[56:60],
-	2048: _Flag_name[60:63],
-}
-
-func (i Flag) String() string {
-	if str, ok := _Flag_map[i]; ok {
-		return str
-	}
-	return "Flag(" + strconv.FormatInt(int64(i), 10) + ")"
-}

input/value/float64.go

@@ -1,44 +1,128 @@
 package value
 
 import (
-	"strconv"
-
-	"gitoa.ru/go-4devs/console/input/value/flag"
+	"fmt"
+	"time"
 )
 
-type Float64 struct {
-	empty
-	Val  []float64
-	Flag flag.Flag
+var (
+	_ ParseValue = Float64(0)
+	_ SliceValue = Float64s{}
+)
+
+func NewFloat64s(in []float64) Slice {
+	return Slice{SliceValue: Float64s(in)}
 }
 
-func (f *Float64) Append(in string) error {
-	v, err := strconv.ParseFloat(in, 64)
-	if err != nil {
-		return err
+type Float64s []float64
+
+func (f Float64s) Any() interface{} {
+	return f.Float64s()
+}
+
+func (f Float64s) Unmarshal(val interface{}) error {
+	v, ok := val.(*[]float64)
+	if !ok {
+		return fmt.Errorf("%w: expect *[]float64", ErrWrongType)
 	}
 
-	f.Val = append(f.Val, v)
+	*v = f
 
 	return nil
 }
 
-func (f *Float64) Float64() float64 {
-	if !f.Flag.IsArray() && len(f.Val) == 1 {
-		return f.Val[0]
+func (f Float64s) Strings() []string {
+	return nil
+}
+
+func (f Float64s) Ints() []int {
+	return nil
+}
+
+func (f Float64s) Int64s() []int64 {
+	return nil
+}
+
+func (f Float64s) Uints() []uint {
+	return nil
+}
+
+func (f Float64s) Uint64s() []uint64 {
+	return nil
+}
+
+func (f Float64s) Float64s() []float64 {
+	out := make([]float64, len(f))
+	copy(out, f)
+
+	return out
+}
+
+func (f Float64s) Bools() []bool {
+	return nil
+}
+
+func (f Float64s) Durations() []time.Duration {
+	return nil
+}
+
+func (f Float64s) Times() []time.Time {
+	return nil
+}
+
+func NewFloat64(in float64) Read {
+	return Read{ParseValue: Float64(in)}
+}
+
+type Float64 float64
+
+func (f Float64) Any() interface{} {
+	return float64(f)
+}
+
+func (f Float64) ParseString() (string, error) {
+	return fmt.Sprint(float64(f)), nil
+}
+
+func (f Float64) ParseInt() (int, error) {
+	return int(f), nil
+}
+
+func (f Float64) ParseInt64() (int64, error) {
+	return int64(f), nil
+}
+
+func (f Float64) ParseUint() (uint, error) {
+	return uint(f), nil
+}
+
+func (f Float64) ParseUint64() (uint64, error) {
+	return uint64(f), nil
+}
+
+func (f Float64) ParseFloat64() (float64, error) {
+	return float64(f), nil
+}
+
+func (f Float64) ParseBool() (bool, error) {
+	return false, fmt.Errorf("float64:%w", ErrWrongType)
+}
+
+func (f Float64) ParseDuration() (time.Duration, error) {
+	return time.Duration(f), nil
+}
+
+func (f Float64) ParseTime() (time.Time, error) {
+	return time.Unix(0, int64(f*Float64(time.Second))), nil
+}
+
+func (f Float64) Unmarshal(in interface{}) error {
+	v, ok := in.(*float64)
+	if !ok {
+		return fmt.Errorf("%w: expect *float64", ErrWrongType)
 	}
 
-	return 0
-}
+	*v = float64(f)
 
-func (f *Float64) Float64s() []float64 {
-	return f.Val
-}
-
-func (f *Float64) Any() interface{} {
-	if f.Flag.IsArray() {
-		return f.Float64s()
-	}
-
-	return f.Float64()
+	return nil
 }

input/value/float64_test.go

@@ -0,0 +1,47 @@
+package value_test
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gitoa.ru/go-4devs/console/input/value"
+)
+
+func TestFloat64_Unmarshal(t *testing.T) {
+	t.Parallel()
+
+	f := value.Float64(math.Pi)
+
+	var out float64
+
+	require.NoError(t, f.Unmarshal(&out))
+	require.Equal(t, math.Pi, out)
+}
+
+func TestFloat64_Any(t *testing.T) {
+	t.Parallel()
+
+	f := value.Float64(math.Pi)
+
+	require.Equal(t, math.Pi, f.Any())
+}
+
+func TestFloat64s_Unmarshal(t *testing.T) {
+	t.Parallel()
+
+	f := value.Float64s{math.Pi, math.Sqrt2}
+
+	var out []float64
+
+	require.NoError(t, f.Unmarshal(&out))
+	require.Equal(t, []float64{math.Pi, math.Sqrt2}, out)
+}
+
+func TestFloat64s_Any(t *testing.T) {
+	t.Parallel()
+
+	f := value.Float64s{math.Pi, math.Sqrt2}
+
+	require.Equal(t, []float64{math.Pi, math.Sqrt2}, f.Any())
+}

input/value/int.go

@@ -1,44 +1,129 @@
 package value
 
 import (
+	"fmt"
 	"strconv"
-
-	"gitoa.ru/go-4devs/console/input/value/flag"
+	"time"
 )
 
-type Int struct {
-	empty
-	Val  []int
-	Flag flag.Flag
+var (
+	_ ParseValue = Int(0)
+	_ SliceValue = Ints{}
+)
+
+func NewInts(in []int) Slice {
+	return Slice{SliceValue: Ints(in)}
 }
 
-func (i *Int) Append(in string) error {
-	v, err := strconv.Atoi(in)
-	if err != nil {
-		return err
+type Ints []int
+
+func (i Ints) Unmarshal(in interface{}) error {
+	val, ok := in.(*[]int)
+	if !ok {
+		return fmt.Errorf("%w: expect *[]int", ErrWrongType)
 	}
 
-	i.Val = append(i.Val, v)
+	*val = i
 
 	return nil
 }
 
-func (i *Int) Int() int {
-	if !i.Flag.IsArray() && len(i.Val) == 1 {
-		return i.Val[0]
+func (i Ints) Any() interface{} {
+	return i.Ints()
+}
+
+func (i Ints) Strings() []string {
+	return nil
+}
+
+func (i Ints) Ints() []int {
+	out := make([]int, len(i))
+	copy(out, i)
+
+	return out
+}
+
+func (i Ints) Int64s() []int64 {
+	return nil
+}
+
+func (i Ints) Uints() []uint {
+	return nil
+}
+
+func (i Ints) Uint64s() []uint64 {
+	return nil
+}
+
+func (i Ints) Float64s() []float64 {
+	return nil
+}
+
+func (i Ints) Bools() []bool {
+	return nil
+}
+
+func (i Ints) Durations() []time.Duration {
+	return nil
+}
+
+func (i Ints) Times() []time.Time {
+	return nil
+}
+
+func NewInt(in int) Read {
+	return Read{ParseValue: Int(in)}
+}
+
+type Int int
+
+func (i Int) Unmarshal(in interface{}) error {
+	v, ok := in.(*int)
+	if !ok {
+		return fmt.Errorf("%w: expect *int", ErrWrongType)
 	}
 
-	return 0
+	*v = int(i)
+
+	return nil
 }
 
-func (i *Int) Ints() []int {
-	return i.Val
+func (i Int) ParseString() (string, error) {
+	return strconv.Itoa(int(i)), nil
 }
 
-func (i *Int) Any() interface{} {
-	if i.Flag.IsArray() {
-		return i.Ints()
-	}
-
-	return i.Int()
+func (i Int) ParseInt() (int, error) {
+	return int(i), nil
+}
+
+func (i Int) ParseInt64() (int64, error) {
+	return int64(i), nil
+}
+
+func (i Int) ParseUint() (uint, error) {
+	return uint(i), nil
+}
+
+func (i Int) ParseUint64() (uint64, error) {
+	return uint64(i), nil
+}
+
+func (i Int) ParseFloat64() (float64, error) {
+	return float64(i), nil
+}
+
+func (i Int) ParseBool() (bool, error) {
+	return false, fmt.Errorf("int:%w", ErrWrongType)
+}
+
+func (i Int) ParseDuration() (time.Duration, error) {
+	return time.Duration(i), nil
+}
+
+func (i Int) ParseTime() (time.Time, error) {
+	return time.Unix(0, int64(i)), nil
+}
+
+func (i Int) Any() interface{} {
+	return int(i)
 }

input/value/int64.go

@@ -1,44 +1,129 @@
 package value
 
 import (
+	"fmt"
 	"strconv"
-
-	"gitoa.ru/go-4devs/console/input/value/flag"
+	"time"
 )
 
-type Int64 struct {
-	empty
-	Val  []int64
-	Flag flag.Flag
+var (
+	_ ParseValue = Int64(0)
+	_ SliceValue = Int64s{}
+)
+
+func NewInt64s(in []int64) Slice {
+	return Slice{SliceValue: Int64s(in)}
 }
 
-func (i *Int64) Int64() int64 {
-	if !i.Flag.IsArray() && len(i.Val) == 1 {
-		return i.Val[0]
+type Int64s []int64
+
+func (i Int64s) Any() interface{} {
+	return i.Int64s()
+}
+
+func (i Int64s) Unmarshal(val interface{}) error {
+	v, ok := val.(*[]int64)
+	if !ok {
+		return fmt.Errorf("%w: expect *[]int64", ErrWrongType)
 	}
 
-	return 0
-}
-
-func (i *Int64) Int64s() []int64 {
-	return i.Val
-}
-
-func (i *Int64) Any() interface{} {
-	if i.Flag.IsArray() {
-		return i.Int64s()
-	}
-
-	return i.Int64()
-}
-
-func (i *Int64) Append(in string) error {
-	v, err := strconv.ParseInt(in, 10, 64)
-	if err != nil {
-		return err
-	}
-
-	i.Val = append(i.Val, v)
+	*v = i
+
+	return nil
+}
+
+func (i Int64s) Strings() []string {
+	return nil
+}
+
+func (i Int64s) Ints() []int {
+	return nil
+}
+
+func (i Int64s) Int64s() []int64 {
+	out := make([]int64, len(i))
+	copy(out, i)
+
+	return out
+}
+
+func (i Int64s) Uints() []uint {
+	return nil
+}
+
+func (i Int64s) Uint64s() []uint64 {
+	return nil
+}
+
+func (i Int64s) Float64s() []float64 {
+	return nil
+}
+
+func (i Int64s) Bools() []bool {
+	return nil
+}
+
+func (i Int64s) Durations() []time.Duration {
+	return nil
+}
+
+func (i Int64s) Times() []time.Time {
+	return nil
+}
+
+func NewInt64(in int64) Read {
+	return Read{ParseValue: Int64(in)}
+}
+
+type Int64 int64
+
+func (i Int64) Any() interface{} {
+	return int64(i)
+}
+
+func (i Int64) ParseString() (string, error) {
+	return strconv.FormatInt(int64(i), 10), nil
+}
+
+func (i Int64) ParseInt() (int, error) {
+	return int(i), nil
+}
+
+func (i Int64) ParseInt64() (int64, error) {
+	return int64(i), nil
+}
+
+func (i Int64) ParseUint() (uint, error) {
+	return uint(i), nil
+}
+
+func (i Int64) ParseUint64() (uint64, error) {
+	return uint64(i), nil
+}
+
+func (i Int64) ParseFloat64() (float64, error) {
+	return float64(i), nil
+}
+
+func (i Int64) ParseBool() (bool, error) {
+	return false, fmt.Errorf("int64:%w", ErrWrongType)
+}
+
+func (i Int64) ParseDuration() (time.Duration, error) {
+	return time.Duration(i), nil
+}
+
+func (i Int64) ParseTime() (time.Time, error) {
+	return time.Unix(0, int64(i)), nil
+}
+
+func (i Int64) Unmarshal(val interface{}) error {
+	v, ok := val.(*int64)
+	if !ok {
+		return fmt.Errorf("%w: expect *int64", ErrWrongType)
+	}
+
+	*v = int64(i)
 
 	return nil
 }

input/value/read.go

@@ -1,20 +1,189 @@
 package value
 
 import (
-	"errors"
-)
+	"fmt"
+	"time"
 
-var _ Append = (*Read)(nil)
+	"gitoa.ru/go-4devs/console/input/errs"
+)
 
 var (
-	ErrAppendRead  = errors.New("invalid append data to read value")
-	ErrAppendEmpty = errors.New("invalid apped data to empty value")
+	_ Value = Read{}
+	_ Value = Slice{}
 )
 
+var ErrWrongType = errs.ErrWrongType
+
 type Read struct {
-	Value
+	ParseValue
 }
 
-func (r *Read) Append(string) error {
-	return ErrAppendRead
+func (r Read) String() string {
+	sout, _ := r.ParseValue.ParseString()
+
+	return sout
+}
+
+func (r Read) Int() int {
+	iout, _ := r.ParseValue.ParseInt()
+
+	return iout
+}
+
+func (r Read) Int64() int64 {
+	iout, _ := r.ParseValue.ParseInt64()
+
+	return iout
+}
+
+func (r Read) Uint() uint {
+	uout, _ := r.ParseValue.ParseUint()
+
+	return uout
+}
+
+func (r Read) Uint64() uint64 {
+	uout, _ := r.ParseValue.ParseUint64()
+
+	return uout
+}
+
+func (r Read) Float64() float64 {
+	fout, _ := r.ParseValue.ParseFloat64()
+
+	return fout
+}
+
+func (r Read) Bool() bool {
+	bout, _ := r.ParseValue.ParseBool()
+
+	return bout
+}
+
+func (r Read) Duration() time.Duration {
+	dout, _ := r.ParseValue.ParseDuration()
+
+	return dout
+}
+
+func (r Read) Time() time.Time {
+	tout, _ := r.ParseValue.ParseTime()
+
+	return tout
+}
+
+func (r Read) Strings() []string {
+	return []string{r.String()}
+}
+
+func (r Read) Ints() []int {
+	return []int{r.Int()}
+}
+
+func (r Read) Int64s() []int64 {
+	return []int64{r.Int64()}
+}
+
+func (r Read) Uints() []uint {
+	return []uint{r.Uint()}
+}
+
+func (r Read) Uint64s() []uint64 {
+	return []uint64{r.Uint64()}
+}
+
+func (r Read) Float64s() []float64 {
+	return []float64{r.Float64()}
+}
+
+func (r Read) Bools() []bool {
+	return []bool{r.Bool()}
+}
+
+func (r Read) Durations() []time.Duration {
+	return []time.Duration{r.Duration()}
+}
+
+func (r Read) Times() []time.Time {
+	return []time.Time{r.Time()}
+}
+
+type Slice struct {
+	SliceValue
+}
+
+func (s Slice) String() string {
+	return ""
+}
+
+func (s Slice) Int() int {
+	return 0
+}
+
+func (s Slice) Int64() int64 {
+	return 0
+}
+
+func (s Slice) Uint() uint {
+	return 0
+}
+
+func (s Slice) Uint64() uint64 {
+	return 0
+}
+
+func (s Slice) Float64() float64 {
+	return 0
+}
+
+func (s Slice) Bool() bool {
+	return false
+}
+
+func (s Slice) Duration() time.Duration {
+	return 0
+}
+
+func (s Slice) Time() time.Time {
+	return time.Time{}
+}
+
+func (s Slice) wrongType() error {
+	return fmt.Errorf("%w: for %T", ErrWrongType, s.SliceValue)
+}
+
+func (s Slice) ParseString() (string, error) {
+	return "", s.wrongType()
+}
+
+func (s Slice) ParseInt() (int, error) {
+	return 0, s.wrongType()
+}
+
+func (s Slice) ParseInt64() (int64, error) {
+	return 0, s.wrongType()
+}
+
+func (s Slice) ParseUint() (uint, error) {
+	return 0, s.wrongType()
+}
+
+func (s Slice) ParseUint64() (uint64, error) {
+	return 0, s.wrongType()
+}
+
+func (s Slice) ParseFloat64() (float64, error) {
+	return 0, s.wrongType()
+}
+
+func (s Slice) ParseBool() (bool, error) {
+	return false, s.wrongType()
+}
+
+func (s Slice) ParseDuration() (time.Duration, error) {
+	return 0, s.wrongType()
+}
+
+func (s Slice) ParseTime() (time.Time, error) {
+	return time.Time{}, s.wrongType()
 }

input/value/string.go

@@ -1,39 +1,172 @@
 package value
 
-import "gitoa.ru/go-4devs/console/input/value/flag"
+import (
+	"fmt"
+	"strconv"
+	"time"
+)
 
-type String struct {
-	empty
-	Val  []string
-	Flag flag.Flag
+var (
+	_ ParseValue = (String)("")
+	_ SliceValue = (Strings)(nil)
+)
+
+func NewStrings(in []string) Slice {
+	return Slice{SliceValue: Strings(in)}
 }
 
-func (s *String) Append(in string) error {
-	s.Val = append(s.Val, in)
+type Strings []string
+
+func (s Strings) Unmarshal(in interface{}) error {
+	val, ok := in.(*[]string)
+	if !ok {
+		return fmt.Errorf("%w: expect *[]string", ErrWrongType)
+	}
+
+	*val = s
 
 	return nil
 }
 
-func (s *String) String() string {
-	if s.Flag.IsArray() {
-		return ""
-	}
-
-	if len(s.Val) == 1 {
-		return s.Val[0]
-	}
-
-	return ""
+func (s Strings) Any() interface{} {
+	return s.Strings()
 }
 
-func (s *String) Strings() []string {
-	return s.Val
+func (s Strings) Strings() []string {
+	out := make([]string, len(s))
+	copy(out, s)
+
+	return out
 }
 
-func (s *String) Any() interface{} {
-	if s.Flag.IsArray() {
-		return s.Strings()
+func (s Strings) Ints() []int {
+	return nil
+}
+
+func (s Strings) Int64s() []int64 {
+	return nil
+}
+
+func (s Strings) Uints() []uint {
+	return nil
+}
+
+func (s Strings) Uint64s() []uint64 {
+	return nil
+}
+
+func (s Strings) Float64s() []float64 {
+	return nil
+}
+
+func (s Strings) Bools() []bool {
+	return nil
+}
+
+func (s Strings) Durations() []time.Duration {
+	return nil
+}
+
+func (s Strings) Times() []time.Time {
+	return nil
+}
+
+func NewString(in string) Value {
+	return Read{ParseValue: String(in)}
+}
+
+type String string
+
+func (s String) ParseString() (string, error) {
+	return string(s), nil
+}
+
+func (s String) Unmarshal(in interface{}) error {
+	v, ok := in.(*string)
+	if !ok {
+		return fmt.Errorf("%w: expect *string", ErrWrongType)
 	}
 
-	return s.String()
+	*v = string(s)
+
+	return nil
+}
+
+func (s String) Any() interface{} {
+	return string(s)
+}
+
+func (s String) ParseInt() (int, error) {
+	v, err := strconv.Atoi(string(s))
+	if err != nil {
+		return 0, fmt.Errorf("string int:%w", err)
+	}
+
+	return v, nil
+}
+
+func (s String) Int64() int64 {
+	out, _ := s.ParseInt64()
+
+	return out
+}
+
+func (s String) ParseInt64() (int64, error) {
+	v, err := strconv.ParseInt(string(s), 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("string int64:%w", err)
+	}
+
+	return v, nil
+}
+
+func (s String) ParseUint() (uint, error) {
+	uout, err := s.ParseUint64()
+
+	return uint(uout), err
+}
+
+func (s String) ParseUint64() (uint64, error) {
+	uout, err := strconv.ParseUint(string(s), 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("string uint:%w", err)
+	}
+
+	return uout, nil
+}
+
+func (s String) ParseFloat64() (float64, error) {
+	fout, err := strconv.ParseFloat(string(s), 64)
+	if err != nil {
+		return 0, fmt.Errorf("string float64:%w", err)
+	}
+
+	return fout, nil
+}
+
+func (s String) ParseBool() (bool, error) {
+	v, err := strconv.ParseBool(string(s))
+	if err != nil {
+		return false, fmt.Errorf("string bool:%w", err)
+	}
+
+	return v, nil
+}
+
+func (s String) ParseDuration() (time.Duration, error) {
+	v, err := time.ParseDuration(string(s))
+	if err != nil {
+		return 0, fmt.Errorf("string duration:%w", err)
+	}
+
+	return v, nil
+}
+
+func (s String) ParseTime() (time.Time, error) {
+	v, err := time.Parse(time.RFC3339, string(s))
+	if err != nil {
+		return time.Time{}, fmt.Errorf("string time:%w", err)
+	}
+
+	return v, nil
 }

input/value/string_test.go

@@ -0,0 +1,28 @@
+package value_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gitoa.ru/go-4devs/console/input/value"
+)
+
+func TestStringUnmarshal(t *testing.T) {
+	t.Parallel()
+
+	st := value.New("test")
+	sta := value.New([]string{"test1", "test2"})
+
+	ac := ""
+	require.NoError(t, st.Unmarshal(&ac))
+	require.Equal(t, "test", ac)
+
+	aca := []string{}
+	require.NoError(t, sta.Unmarshal(&aca))
+	require.Equal(t, []string{"test1", "test2"}, aca)
+
+	require.ErrorIs(t, sta.Unmarshal(ac), value.ErrWrongType)
+	require.ErrorIs(t, sta.Unmarshal(&ac), value.ErrWrongType)
+	require.ErrorIs(t, st.Unmarshal(aca), value.ErrWrongType)
+	require.ErrorIs(t, st.Unmarshal(&aca), value.ErrWrongType)
+}

input/value/time.go

@@ -1,44 +1,130 @@
 package value
 
 import (
+	"fmt"
 	"time"
-
-	"gitoa.ru/go-4devs/console/input/value/flag"
 )
 
-type Time struct {
-	empty
-	Val  []time.Time
-	Flag flag.Flag
+var (
+	_ ParseValue = Time{time.Now()}
+	_ SliceValue = (Times)(nil)
+)
+
+func NewTimes(in []time.Time) Slice {
+	return Slice{SliceValue: Times(in)}
 }
 
-func (t *Time) Append(in string) error {
-	v, err := time.Parse(time.RFC3339, in)
-	if err != nil {
-		return err
+type Times []time.Time
+
+func (t Times) Any() interface{} {
+	return t.Times()
+}
+
+func (t Times) Unmarshal(val interface{}) error {
+	res, ok := val.(*[]time.Time)
+	if !ok {
+		return fmt.Errorf("%w: expect *[]time.Time", ErrWrongType)
 	}
 
-	t.Val = append(t.Val, v)
+	*res = t
 
 	return nil
 }
 
-func (t *Time) Time() time.Time {
-	if !t.Flag.IsArray() && len(t.Val) == 1 {
-		return t.Val[0]
+func (t Times) Strings() []string {
+	return nil
+}
+
+func (t Times) Ints() []int {
+	return nil
+}
+
+func (t Times) Int64s() []int64 {
+	return nil
+}
+
+func (t Times) Uints() []uint {
+	return nil
+}
+
+func (t Times) Uint64s() []uint64 {
+	return nil
+}
+
+func (t Times) Float64s() []float64 {
+	return nil
+}
+
+func (t Times) Bools() []bool {
+	return nil
+}
+
+func (t Times) Durations() []time.Duration {
+	return nil
+}
+
+func (t Times) Times() []time.Time {
+	out := make([]time.Time, len(t))
+	copy(out, t)
+
+	return out
+}
+
+func NewTime(in time.Time) Read {
+	return Read{ParseValue: Time{Time: in}}
+}
+
+type Time struct {
+	time.Time
+}
+
+func (t Time) ParseString() (string, error) {
+	return t.Format(time.RFC3339), nil
+}
+
+func (t Time) ParseInt() (int, error) {
+	return int(t.Unix()), nil
+}
+
+func (t Time) ParseInt64() (int64, error) {
+	return t.Unix(), nil
+}
+
+func (t Time) ParseUint() (uint, error) {
+	return uint(t.Unix()), nil
+}
+
+func (t Time) ParseUint64() (uint64, error) {
+	return uint64(t.Unix()), nil
+}
+
+func (t Time) ParseFloat64() (float64, error) {
+	return float64(t.UnixNano()), nil
+}
+
+func (t Time) ParseBool() (bool, error) {
+	return false, fmt.Errorf("time bool:%w", ErrWrongType)
+}
+
+func (t Time) ParseDuration() (time.Duration, error) {
+	return 0, fmt.Errorf("time duration:%w", ErrWrongType)
+}
+
+func (t Time) ParseTime() (time.Time, error) {
+	return t.Time, nil
+}
+
+func (t Time) Unmarshal(val interface{}) error {
+	res, ok := val.(*time.Time)
+	if !ok {
+		return fmt.Errorf("%w: expect *time.Time", ErrWrongType)
 	}
 
-	return time.Time{}
+	*res = t.Time
+
+	return nil
 }
 
-func (t *Time) Times() []time.Time {
-	return t.Val
-}
-
-func (t *Time) Amy() interface{} {
-	if t.Flag.IsArray() {
-		return t.Times()
-	}
-
-	return t.Time()
+func (t Time) Any() interface{} {
+	return t.Time
 }

input/value/uint.go

@@ -1,44 +1,129 @@
 package value
 
 import (
+	"fmt"
 	"strconv"
-
-	"gitoa.ru/go-4devs/console/input/value/flag"
+	"time"
 )
 
-type Uint struct {
-	empty
-	Val  []uint
-	Flag flag.Flag
+var (
+	_ ParseValue = Uint(0)
+	_ SliceValue = (Uints)(nil)
+)
+
+func NewUints(in []uint) Slice {
+	return Slice{SliceValue: Uints(in)}
 }
 
-func (u *Uint) Append(in string) error {
-	v, err := strconv.ParseUint(in, 10, 64)
-	if err != nil {
-		return err
+type Uints []uint
+
+func (u Uints) Any() interface{} {
+	return u.Uints()
+}
+
+func (u Uints) Unmarshal(val interface{}) error {
+	res, ok := val.(*[]uint)
+	if !ok {
+		return fmt.Errorf("%w: expect *[]uint", ErrWrongType)
 	}
 
-	u.Val = append(u.Val, uint(v))
+	*res = u
 
 	return nil
 }
 
-func (u *Uint) Uint() uint {
-	if !u.Flag.IsArray() && len(u.Val) == 1 {
-		return u.Val[0]
+func (u Uints) Strings() []string {
+	return nil
+}
+
+func (u Uints) Ints() []int {
+	return nil
+}
+
+func (u Uints) Int64s() []int64 {
+	return nil
+}
+
+func (u Uints) Uints() []uint {
+	out := make([]uint, len(u))
+	copy(out, u)
+
+	return out
+}
+
+func (u Uints) Uint64s() []uint64 {
+	return nil
+}
+
+func (u Uints) Float64s() []float64 {
+	return nil
+}
+
+func (u Uints) Bools() []bool {
+	return nil
+}
+
+func (u Uints) Durations() []time.Duration {
+	return nil
+}
+
+func (u Uints) Times() []time.Time {
+	return nil
+}
+
+func NewUint(in uint) Read {
+	return Read{ParseValue: Uint(in)}
+}
+
+type Uint uint
+
+func (u Uint) ParseString() (string, error) {
+	return strconv.FormatUint(uint64(u), 10), nil
+}
+
+func (u Uint) ParseInt() (int, error) {
+	return int(u), nil
+}
+
+func (u Uint) ParseInt64() (int64, error) {
+	return int64(u), nil
+}
+
+func (u Uint) ParseUint() (uint, error) {
+	return uint(u), nil
+}
+
+func (u Uint) ParseUint64() (uint64, error) {
+	return uint64(u), nil
+}
+
+func (u Uint) ParseFloat64() (float64, error) {
+	return float64(u), nil
+}
+
+func (u Uint) ParseBool() (bool, error) {
+	return false, fmt.Errorf("uint:%w", ErrWrongType)
+}
+
+func (u Uint) ParseDuration() (time.Duration, error) {
+	return time.Duration(u), nil
+}
+
+func (u Uint) ParseTime() (time.Time, error) {
+	return time.Unix(0, int64(u)), nil
+}
+
+func (u Uint) Unmarshal(val interface{}) error {
+	res, ok := val.(*uint)
+	if !ok {
+		return fmt.Errorf("%w: expect *uint", ErrWrongType)
 	}
 
-	return 0
+	*res = uint(u)
+
+	return nil
 }
 
-func (u *Uint) Uints() []uint {
-	return u.Val
-}
-
-func (u *Uint) Any() interface{} {
-	if u.Flag.IsArray() {
-		return u.Uints()
-	}
-
-	return u.Uint()
+func (u Uint) Any() interface{} {
+	return uint(u)
 }

input/value/uint64.go

@@ -1,44 +1,129 @@
 package value
 
 import (
+	"fmt"
 	"strconv"
-
-	"gitoa.ru/go-4devs/console/input/value/flag"
+	"time"
 )
 
-type Uint64 struct {
-	empty
-	Val  []uint64
-	Flag flag.Flag
+var (
+	_ ParseValue = Uint64(0)
+	_ SliceValue = (Uint64s)(nil)
+)
+
+func NewUint64s(in []uint64) Slice {
+	return Slice{SliceValue: Uint64s(in)}
 }
 
-func (u *Uint64) Append(in string) error {
-	v, err := strconv.ParseUint(in, 10, 64)
-	if err != nil {
-		return err
+type Uint64s []uint64
+
+func (u Uint64s) Any() interface{} {
+	return u.Uint64s()
+}
+
+func (u Uint64s) Unmarshal(val interface{}) error {
+	res, ok := val.(*[]uint64)
+	if !ok {
+		return fmt.Errorf("%w: expect *[]uint64", ErrWrongType)
 	}
 
-	u.Val = append(u.Val, v)
+	*res = u
 
 	return nil
 }
 
-func (u *Uint64) Uint64() uint64 {
-	if !u.Flag.IsArray() && len(u.Val) == 1 {
-		return u.Val[0]
+func (u Uint64s) Strings() []string {
+	return nil
+}
+
+func (u Uint64s) Ints() []int {
+	return nil
+}
+
+func (u Uint64s) Int64s() []int64 {
+	return nil
+}
+
+func (u Uint64s) Uints() []uint {
+	return nil
+}
+
+func (u Uint64s) Uint64s() []uint64 {
+	out := make([]uint64, len(u))
+	copy(out, u)
+
+	return out
+}
+
+func (u Uint64s) Float64s() []float64 {
+	return nil
+}
+
+func (u Uint64s) Bools() []bool {
+	return nil
+}
+
+func (u Uint64s) Durations() []time.Duration {
+	return nil
+}
+
+func (u Uint64s) Times() []time.Time {
+	return nil
+}
+
+func NewUint64(in uint64) Read {
+	return Read{ParseValue: Uint64(in)}
+}
+
+type Uint64 uint64
+
+func (u Uint64) ParseString() (string, error) {
+	return strconv.FormatUint(uint64(u), 10), nil
+}
+
+func (u Uint64) ParseInt() (int, error) {
+	return int(u), nil
+}
+
+func (u Uint64) ParseInt64() (int64, error) {
+	return int64(u), nil
+}
+
+func (u Uint64) ParseUint() (uint, error) {
+	return uint(u), nil
+}
+
+func (u Uint64) ParseUint64() (uint64, error) {
+	return uint64(u), nil
+}
+
+func (u Uint64) ParseFloat64() (float64, error) {
+	return float64(u), nil
+}
+
+func (u Uint64) ParseBool() (bool, error) {
+	return false, fmt.Errorf("uint64 bool:%w", ErrWrongType)
+}
+
+func (u Uint64) ParseDuration() (time.Duration, error) {
+	return time.Duration(u), nil
+}
+
+func (u Uint64) ParseTime() (time.Time, error) {
+	return time.Unix(0, int64(0)), nil
+}
+
+func (u Uint64) Unmarshal(val interface{}) error {
+	res, ok := val.(*uint64)
+	if !ok {
+		return fmt.Errorf("%w: expect *uint64", ErrWrongType)
 	}
 
-	return 0
+	*res = uint64(u)
+
+	return nil
 }
 
-func (u *Uint64) Uint64s() []uint64 {
-	return u.Val
-}
-
-func (u *Uint64) Any() interface{} {
-	if u.Flag.IsArray() {
-		return u.Uint64s()
-	}
-
-	return u.Uint64()
+func (u Uint64) Any() interface{} {
+	return uint64(u)
 }

input/value/value.go

@@ -2,11 +2,19 @@ package value
 
 import (
 	"time"
-
-	"gitoa.ru/go-4devs/console/input/value/flag"
 )
 
 type Value interface {
+	ReadValue
+	ParseValue
+	ArrValue
+}
+
+type UnmarshalValue interface {
+	Unmarshal(val interface{}) error
+}
+
+type ReadValue interface {
 	String() string
 	Int() int
 	Int64() int64
@@ -16,8 +24,19 @@ type Value interface {
 	Bool() bool
 	Duration() time.Duration
 	Time() time.Time
-	Any() interface{}
+}
 
+type AnyValue interface {
+	Any() interface{}
+}
+
+type SliceValue interface {
+	AnyValue
+	UnmarshalValue
+	ArrValue
+}
+
+type ArrValue interface {
 	Strings() []string
 	Ints() []int
 	Int64s() []int64
@@ -29,86 +48,74 @@ type Value interface {
 	Times() []time.Time
 }
 
+//nolint:interfacebloat
+type ParseValue interface {
+	ParseString() (string, error)
+	ParseInt() (int, error)
+	ParseInt64() (int64, error)
+	ParseUint() (uint, error)
+	ParseUint64() (uint64, error)
+	ParseFloat64() (float64, error)
+	ParseBool() (bool, error)
+	ParseDuration() (time.Duration, error)
+	ParseTime() (time.Time, error)
+	UnmarshalValue
+	AnyValue
+}
+
 type Append interface {
 	Value
-	Append(string) error
+	Append(string) (Value, error)
 }
 
-//nolint: gocyclo
-func New(v interface{}) Append {
-	switch val := v.(type) {
-	case string:
-		return &String{Val: []string{val}, Flag: flag.String}
-	case int:
-		return &Int{Val: []int{val}, Flag: flag.Int}
-	case int64:
-		return &Int64{Val: []int64{val}, Flag: flag.Int64}
-	case uint:
-		return &Uint{Val: []uint{val}, Flag: flag.Uint}
-	case uint64:
-		return &Uint64{Val: []uint64{val}, Flag: flag.Uint64}
-	case float64:
-		return &Float64{Val: []float64{val}, Flag: flag.Float64}
+//nolint:gocyclo,cyclop
+func New(in interface{}) Value {
+	switch val := in.(type) {
 	case bool:
-		return &Bool{Val: []bool{val}, Flag: flag.Bool}
-	case time.Duration:
-		return &Duration{Val: []time.Duration{val}, Flag: flag.Duration}
-	case time.Time:
-		return &Time{Val: []time.Time{val}, Flag: flag.Time}
-	case []int64:
-		return &Int64{Val: val, Flag: flag.Int64 | flag.Array}
-	case []uint:
-		return &Uint{Val: val, Flag: flag.Uint | flag.Array}
-	case []uint64:
-		return &Uint64{Val: val, Flag: flag.Uint64 | flag.Array}
-	case []float64:
-		return &Float64{Val: val, Flag: flag.Float64 | flag.Array}
+		return Read{Bool(val)}
 	case []bool:
-		return &Bool{Val: val, Flag: flag.Bool | flag.Array}
+		return NewBools(val)
+	case string:
+		return Read{String(val)}
+	case int:
+		return Read{Int(val)}
+	case int64:
+		return Read{Int64(val)}
+	case uint:
+		return Read{Uint(val)}
+	case uint64:
+		return Read{Uint64(val)}
+	case float64:
+		return Read{Float64(val)}
+	case time.Duration:
+		return Read{Duration(val)}
+	case time.Time:
+		return Read{Time{val}}
+	case []int64:
+		return Slice{Int64s(val)}
+	case []uint:
+		return Slice{Uints(val)}
+	case []uint64:
+		return Slice{Uint64s(val)}
+	case []float64:
+		return Slice{Float64s(val)}
 	case []time.Duration:
-		return &Duration{Val: val, Flag: flag.Duration | flag.Array}
+		return Slice{Durations(val)}
 	case []time.Time:
-		return &Time{Val: val, Flag: flag.Time | flag.Array}
+		return Slice{Times(val)}
 	case []string:
-		return &String{Val: val, Flag: flag.String | flag.Array}
+		return Slice{Strings(val)}
 	case []int:
-		return &Int{Val: val, Flag: flag.Int | flag.Array}
+		return Slice{Ints(val)}
 	case []interface{}:
-		return &Any{Val: val, Flag: flag.Any | flag.Array}
-	case Append:
-		return val
+		return Read{Any{v: val}}
 	case Value:
-		return &Read{Value: val}
+		return val
 	default:
-		if v != nil {
-			return &Any{Val: []interface{}{v}, Flag: flag.Any}
+		if in != nil {
+			return Read{Any{v: in}}
 		}
 
-		return &empty{}
-	}
-}
-
-func ByFlag(f flag.Flag) Append {
-	switch {
-	case f.IsInt():
-		return &Int{Flag: f | flag.Int}
-	case f.IsInt64():
-		return &Int64{Flag: f | flag.Int64}
-	case f.IsUint():
-		return &Uint{Flag: f | flag.Uint}
-	case f.IsUint64():
-		return &Uint64{Flag: f | flag.Uint64}
-	case f.IsFloat64():
-		return &Float64{Flag: f | flag.Float64}
-	case f.IsBool():
-		return &Bool{Flag: f | flag.Bool}
-	case f.IsDuration():
-		return &Duration{Flag: f | flag.Duration}
-	case f.IsTime():
-		return &Time{Flag: f | flag.Time}
-	case f.IsAny():
-		return &Any{Flag: f | flag.Any}
-	default:
-		return &String{}
+		return Empty()
 	}
 }