Does V have a map[string]any{} dictionary type?

[Avey777]

If the map can support different types of values, it will be very concise for organizing data.

In addition to using struct, is there a better way to implement similar data structures more quickly?

[Delta456]

Instead of Any you can use sum types and make a map for the same.

[Avey777]

type Any = string | int | map[string]string | []string | map[string]Any

fn main() {
    mut m := map[string]Any{}
    mut n := map[string]Any{}
    m["key1"] = "Hello"
    m["key2"] = 123
    m["key3"] = "123"
    m["key4"] = ["str1","str2"]

    n["n1"] = "word"
    n["n2"] = 456
    m["key5"] = n
    println(m)
}

---

(base) root@Jengro:/home/jengro/dev/vprod# v run .
{'key1': Any('Hello'), 'key2': Any(123), 'key3': Any('123'), 'key4': Any(['str1', 'str2']), 'key5': Any({'n1': Any('word'), 'n2': Any(456)})}

[Avey777]

println(json.encode(m))

{"key1":"Hello","key2":123,"key3":"123","key4":["str1","str2"],"key5":{"n1":"word","n2":456,"_type":"Any"}}

The extra "_type":"Any" will affect the use of data.

[changrui]

type Any = interface{}, then map[string]Any.

[Avey777]

I will try

[Avey777]

keyCan you give me an example? I don't know how to do this.

[JalonSolov]

In other words, you have to intentionally break the rules. V won't allow you to do it by accident.

[Avey777]

module main


type Any = interface{}

fn main(){
  mut m := map[string]Any{}
  m["key1"] = "Hello"
  m["key2"] = 123
  println(m)
}

---

(base) root@Jengro:/home/jengro/dev/vprod# v run .
src/main.v:4:21: error: bad top level statement token `{`
    2 |
    3 |
    4 | type Any = interface{}
      |                     ^
    5 |
    6 | fn main(){
(base) root@Jengro:/home/jengro/dev/vprod#

[changrui]

Sorry, You are right. type Any = int | f64 | string | []Any | map[string]Any.

[Avey777]

module main

import x.json2

type Any = string | i8 | i16 | int | i64 | u8 | u16 | u32 | u64 | f32 | f64 | bool | []string | []i8 | []i16 | []int | []i64 | []u8 | []u16 | []u32 | []u64 | []f32 | []f64 | []bool | []Any | map[string]string | map[int]int | map[string]Any

fn main() {
    mut m := map[string]Any{}
    mut n := map[string]Any{}
    mut o := map[string]Any{}

    m['key1'] = 'Hello'
    m['key2'] = 123
    m['key3'] = '123'
    m['key6'] = f32(3.14)
    m['key7'] = true
    m['key8'] = i8(100)
    m['key9'] = i16(100)
    m['key10'] = i64(100)
    m['key11'] = u8(255)
    m['key12'] = u16(65535)
    m['key13'] = u32(4294967295)
    m['key14'] = u64(18446744073709551615)
    m['key15'] = f64(3.40282366920938463463374607431768211455)
    m['key16'] = f32(12345)

    n['n1'] = 'word'
    n['n2'] = 456
    n['n3'] = false
    n['n4'] = [1, 2, 3]
    n['n5'] = [true, false, true]
    n['n6'] = [i8(100), i8(200)]
    n['n7'] = [i16(100), i16(200)]
    n['n8'] = [i64(100), i64(200)]
    n['n9'] = [u8(255), u8(200)]
    n['n10'] = [u16(65535), u16(200)]
    n['n11'] = [u32(4294967295), u32(200)]
    n['n12'] = [u64(18446744073709551615), u64(200)]
    n['n13'] = [f32(3.14), f32(1.23)]
    n['n14'] = [f64(12345), f64(54321)]

    o['o1'] = 'inner word'
    o['o2'] = 789
    n['n15'] = o  // Nested map inside `n`

    m['key4'] = n  // Nested map `n` inside `m`
    m['key5'] = ['str1', 'str2']

    jn := encode_any(m).json_str()
    println(jn)

    mut json_map := json2.raw_decode(jn) or {
        eprintln('Failed to decode JSON')
        return
    }.as_map()
    println(json_map)
}

fn encode_any(a Any) json2.Any {
    match a {
        string {
            return json2.Any(a as string)
        }
        i8 {
            return json2.Any(a as i8)
        }
        i16 {
            return json2.Any(a as i16)
        }
        int {
            return json2.Any(a as int)
        }
        i64 {
            return json2.Any(a as i64)
        }
        u8 {
            return json2.Any(a as u8)
        }
        u16 {
            return json2.Any(a as u16)
        }
        u32 {
            return json2.Any(a as u32)
        }
        u64 {
            return json2.Any(a as u64)
        }
        f32 {
            return json2.Any(a as f32)
        }
        f64 {
            return json2.Any(a as f64)
        }
        bool {
            return json2.Any(a as bool)
        }
        []string {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []i8 {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []i16 {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []int {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []i64 {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []u8 {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []u16 {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []u32 {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []u64 {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []f32 {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []f64 {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []bool {
            mut result := []json2.Any{}
            for value in a {
                result << json2.Any(value)
            }
            return json2.Any(result)
        }
        []Any {
            mut result := []json2.Any{}
            for value in a {
                result << encode_any(value)
            }
            return json2.Any(result)
        }
        map[string]string {
            mut result := map[string]json2.Any{}
            for key, value in a {
                result[key] = json2.Any(value)
            }
            return json2.Any(result)
        }
        map[int]int {
            mut result := map[string]json2.Any{}
            for key, value in a {
                result[key.str()] = json2.Any(value)
            }
            return json2.Any(result)
        }
        map[string]Any {
            mut result := map[string]json2.Any{}
            for key, value in a {
                result[key] = encode_any(value)
            }
            return json2.Any(result)
        }
    }
}

---

{"key1":"Hello","key2":123,"key3":"123","key6":3.14,"key7":true,"key8":100,"key9":100,"key10":100,"key11":255,"key12":65535,"key13":4294967295,"key14":18446744073709551615,"key15":3.4028236692093845,"key16":12345.0,"key4":{"n1":"word","n2":456,"n3":false,"n4":[1,2,3],"n5":[true,false,true],"n6":[100,-56],"n7":[100,200],"n8":[100,200],"n9":[255,200],"n10":[65535,200],"n11":[4294967295,200],"n12":[18446744073709551615,200],"n13":[3.14,1.23],"n14":[12345.0,54321.0],"n15":{"o1":"inner word","o2":789}},"key5":["str1","str2"]}

---

I think the V language should provide a similar data processing method to make it easier and more convenient for us to use. Instead of letting us encapsulate this ourselves

[Avey777]

The data organization method of map[string]Any is often needed. It would be better if v could support it faster.

[Avey777]

module main
import x.json2

fn main() {
    mut data := map[string]json2.Any{}

    data['name'] = json2.Any('Alice')
    data['age'] = json2.Any(i64(30))
    data['is_student'] = json2.Any(true)
    // data['grades'] = json2.Any([i64(85), i64(98)])
    println(data)
}

---

(base) root@Jengro:/home/jengro/dev/vprod/src/test# v run m.v
m.v:12:28: error: cannot cast `[]i64` to `json2.Any`
   10 |     data['age'] = json2.Any(i64(30))
   11 |     data['is_student'] = json2.Any(true)
   12 |     data['grades'] = json2.Any([i64(85), i64(98)])
      |                            ~~~~~~~~~~~~~~~~~~~~~~~
   13 |     println(data)
   14 | }
(base) root@Jengro:/home/jengro/dev/vprod/src/test# v run m.v
{"name":"Alice","age":30,"is_student":true}
(base) root@Jengro:/home/jengro/dev/vprod/src/test#

json2.Any can basically meet the needs if the key supports int list map