go-dirty.git

diff --git a/main_test.go b/main_test.go
index 684ff94a74e3e024930d77cce40328c0b2c2b398..d4ac92e350dc73b04cf656b72951785023188cea 100644
--- a/main_test.go
+++ b/main_test.go
@@ -287,8 +287,8 @@ 		t.Fatalf("expected [0], got %+v\n", arr)
 	}
 }
 
-// todo test numbers
-func TestShowMap(t *testing.T) {
+// todo test not show
+func TestNumbers(t *testing.T) {
 	r := strings.NewReader(`(1 10 10. 10.5 ↊· ↊·6 1e2 -1 -10 -10.5 -↊· -↊·6 -1e2 1e-2 -1e-2)`)
 
 	arr, err := Load(r)
@@ -298,7 +298,6 @@ 		t.Fatalf("got error: %v\n", err)
 	}
 }
 
-// todo test raw string
 func TestShowRawString(t *testing.T) {
 	r := strings.NewReader("(`\n" +
 		" a\n" +
@@ -367,7 +366,107 @@ 		('a' 11)
 		('b' 42)
 		('c' 3)
 	)`)
-	m := map[string]int64{}
+	m := map[string]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapInt(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[int]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapInt8(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[int8]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapInt16(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[int16]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapInt32(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[int32]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapInt64(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[int64]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapUInt(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[uint]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapUInt8(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[uint8]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapUInt16(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[uint16]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapUInt32(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[uint32]int{}
+	LoadStruct(r, &m)
+}
+
+func TestShowLoadMapUInt64(t *testing.T) {
+	r := strings.NewReader(`(
+		(1 11)
+		(2 42)
+		(4 3)
+	)`)
+	m := map[uint64]int{}
 	LoadStruct(r, &m)
 }
 




diff --git a/struct.go b/struct.go
index ff71c3fdd18074e3bd13edd39d2fcba11a7c4e91..49bfdbc040f819f77705f60f6865828dc81cd18d 100644
--- a/struct.go
+++ b/struct.go
@@ -31,25 +31,44 @@ }
 
 func getStructMapKey(pair Array, mk reflect.Kind) reflect.Value {
 	sk := reflect.ValueOf(pair[0]).Kind()
-	if sk != mk {
+	if (sk == reflect.String && mk != reflect.String) ||
+		(sk == reflect.Int && mk != reflect.Int && mk != reflect.Int8 &&
+			mk != reflect.Int16 && mk != reflect.Int32 && mk != reflect.Int64 &&
+			mk != reflect.Uint && mk != reflect.Uint8 &&
+			mk != reflect.Uint16 && mk != reflect.Uint32 && mk != reflect.Uint64) ||
+			(sk == reflect.Bool && mk != reflect.Bool) {
 		// todo error
 		fmt.Printf("pair[0] (%v) not map key (%v)\n", sk, mk)
 		return reflect.ValueOf(nil)
 	}
-	if sk == reflect.String {
+	switch mk {
+	case reflect.String:
 		return reflect.ValueOf(string(pair[0].(String)))
-	}
-	// fixme
-	if sk == reflect.Int64 {
+	case reflect.Bool:
+		return reflect.ValueOf(pair[0].(Const).Bool())
+	case reflect.Uint:
+		return reflect.ValueOf(uint(pair[0].(Int)))
+	case reflect.Uint8:
+		return reflect.ValueOf(uint8(pair[0].(Int)))
+	case reflect.Uint16:
+		return reflect.ValueOf(uint16(pair[0].(Int)))
+	case reflect.Uint32:
+		return reflect.ValueOf(uint32(pair[0].(Int)))
+	case reflect.Uint64:
+		return reflect.ValueOf(uint64(pair[0].(Int)))
+	case reflect.Int:
 		return reflect.ValueOf(int(pair[0].(Int)))
-	}
-	if sk == reflect.Bool {
-		return reflect.ValueOf(pair[0].(Const).Bool())
-	}
-	if sk == reflect.Float64 {
-		return reflect.ValueOf(float64(pair[0].(Float)))
+	case reflect.Int8:
+		return reflect.ValueOf(int8(pair[0].(Int)))
+	case reflect.Int16:
+		return reflect.ValueOf(int16(pair[0].(Int)))
+	case reflect.Int32:
+		return reflect.ValueOf(int32(pair[0].(Int)))
+	case reflect.Int64:
+		return reflect.ValueOf(int64(pair[0].(Int)))
+	default:
+		return reflect.ValueOf(nil)
 	}
-	return reflect.ValueOf(nil)
 }
 
 func setStructValue(value Element, f reflect.Value) error {