Merge pull request #3 from crodas/feature/hash

Add Hash support

Cargo.toml

@@ -16,3 +16,4 @@ seahash = "4"
 log="0.4"
 env_logger = "0.8.4"
 bytes = "1"
+rand = "0.8.0"

src/cmd/client.rs

@@ -1,6 +1,6 @@
 use crate::{connection::Connection, error::Error, option, value::Value};
-use std::sync::Arc;
 use bytes::Bytes;
+use std::sync::Arc;
 
 pub fn client(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
     let sub = unsafe { std::str::from_utf8_unchecked(&args[1]) }.to_string();
@@ -23,11 +23,10 @@ pub fn client(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
         "getname" => Ok(option!(conn.name())),
         "list" => {
             let mut v: Vec<Value> = vec![];
-            conn.all_connections().iter(&mut |conn: Arc<Connection>| {
-                v.push(conn.info().as_str().into())
-            });
+            conn.all_connections()
+                .iter(&mut |conn: Arc<Connection>| v.push(conn.info().as_str().into()));
             Ok(v.into())
-        },
+        }
         "setname" => {
             let name = unsafe { std::str::from_utf8_unchecked(&args[2]) }.to_string();
             conn.set_name(name);

src/cmd/hash.rs

@@ -0,0 +1,306 @@
+use crate::{
+    check_arg, connection::Connection, error::Error, value::bytes_to_number, value::Value,
+};
+use bytes::Bytes;
+use rand::Rng;
+use std::{
+    collections::{BTreeMap, HashMap},
+    convert::TryFrom,
+    ops::AddAssign,
+    str::FromStr,
+};
+
+pub fn hdel(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    conn.db().get_map(
+        &args[1],
+        |v| match v {
+            Value::Hash(h) => {
+                let mut h = h.write();
+                let mut total: i64 = 0;
+
+                for key in (&args[2..]).iter() {
+                    if h.remove(key).is_some() {
+                        total += 1;
+                    }
+                }
+
+                Ok(total.into())
+            }
+            _ => Err(Error::WrongType),
+        },
+        || Ok(0_i64.into()),
+    )
+}
+
+pub fn hexists(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    match conn.db().get(&args[1]) {
+        Value::Hash(h) => Ok(if h.read().get(&args[2]).is_some() {
+            1_i64.into()
+        } else {
+            0_i64.into()
+        }),
+        Value::Null => Ok(0_i64.into()),
+        _ => Err(Error::WrongType),
+    }
+}
+
+pub fn hget(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    match conn.db().get(&args[1]) {
+        Value::Hash(h) => Ok(if let Some(v) = h.read().get(&args[2]) {
+            Value::Blob(v.clone())
+        } else {
+            Value::Null
+        }),
+        Value::Null => Ok(Value::Null),
+        _ => Err(Error::WrongType),
+    }
+}
+
+pub fn hgetall(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    match conn.db().get(&args[1]) {
+        Value::Hash(h) => {
+            let mut ret = vec![];
+
+            for (key, value) in h.read().iter() {
+                ret.push(Value::Blob(key.clone()));
+                ret.push(Value::Blob(value.clone()));
+            }
+
+            Ok(ret.into())
+        }
+        Value::Null => Ok(Value::Array(vec![])),
+        _ => Err(Error::WrongType),
+    }
+}
+
+pub fn hincrby<
+    T: ToString + FromStr + AddAssign + for<'a> TryFrom<&'a Value, Error = Error> + Into<Value> + Copy,
+>(
+    conn: &Connection,
+    args: &[Bytes],
+) -> Result<Value, Error> {
+    conn.db().get_map(
+        &args[1],
+        |v| match v {
+            Value::Hash(h) => {
+                let mut incr_by: T = bytes_to_number(&args[3])?;
+                let mut h = h.write();
+                if let Some(n) = h.get(&args[2]) {
+                    incr_by += bytes_to_number(n)?;
+                }
+
+                h.insert(args[2].clone(), incr_by.to_string().into());
+
+                Ok(incr_by.into())
+            }
+            _ => Err(Error::WrongType),
+        },
+        || {
+            let incr_by: T = bytes_to_number(&args[3])?;
+            #[allow(clippy::mutable_key_type)]
+            let mut h = HashMap::new();
+            h.insert(args[2].clone(), incr_by.to_string().into());
+            conn.db().set(&args[1], h.into(), None);
+            Ok(incr_by.into())
+        },
+    )
+}
+
+pub fn hkeys(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    match conn.db().get(&args[1]) {
+        Value::Hash(h) => {
+            let mut ret = vec![];
+
+            for key in h.read().keys() {
+                ret.push(Value::Blob(key.clone()));
+            }
+
+            Ok(ret.into())
+        }
+        Value::Null => Ok(Value::Array(vec![])),
+        _ => Err(Error::WrongType),
+    }
+}
+
+pub fn hlen(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    match conn.db().get(&args[1]) {
+        Value::Hash(h) => Ok((h.read().len() as i64).into()),
+        Value::Null => Ok(0_i64.into()),
+        _ => Err(Error::WrongType),
+    }
+}
+
+pub fn hmget(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    match conn.db().get(&args[1]) {
+        Value::Hash(h) => {
+            let h = h.read();
+
+            Ok((&args[2..])
+                .iter()
+                .map(|key| {
+                    if let Some(value) = h.get(key) {
+                        Value::Blob(value.clone())
+                    } else {
+                        Value::Null
+                    }
+                })
+                .collect::<Vec<Value>>()
+                .into())
+        }
+        Value::Null => Ok(Value::Array(vec![])),
+        _ => Err(Error::WrongType),
+    }
+}
+
+pub fn hrandfield(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    let (count, with_values) = match args.len() {
+        2 => (None, false),
+        3 => (Some(bytes_to_number::<i64>(&args[2])?), false),
+        4 => {
+            if !(check_arg!(args, 3, "WITHVALUES")) {
+                return Err(Error::Syntax);
+            }
+            (Some(bytes_to_number::<i64>(&args[2])?), true)
+        }
+        _ => return Err(Error::InvalidArgsCount("hrandfield".to_owned())),
+    };
+    let (count, single, repeat) = if let Some(count) = count {
+        if count > 0 {
+            (count, false, 1)
+        } else {
+            (count.abs(), false, count.abs())
+        }
+    } else {
+        (1, true, 1)
+    };
+
+    match conn.db().get(&args[1]) {
+        Value::Hash(h) => {
+            let mut ret = vec![];
+            let mut i = 0;
+            let mut rand_sorted = BTreeMap::new();
+            let mut rng = rand::thread_rng();
+            let h = h.read();
+
+            for _ in 0..repeat {
+                for (key, value) in h.iter() {
+                    let rand = rng.gen::<u64>();
+                    rand_sorted.insert((rand, i), (key, value));
+                    i += 1;
+                }
+            }
+
+            i = 0;
+            for val in rand_sorted.values() {
+                if single {
+                    return Ok(Value::Blob(val.0.clone()));
+                }
+
+                if i == count {
+                    break;
+                }
+
+                ret.push(Value::Blob(val.0.clone()));
+
+                if with_values {
+                    ret.push(Value::Blob(val.1.clone()));
+                }
+
+                i += 1;
+            }
+
+            Ok(ret.into())
+        }
+        Value::Null => Ok(Value::Array(vec![])),
+        _ => Err(Error::WrongType),
+    }
+}
+
+pub fn hset(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    if args.len() % 2 == 1 {
+        return Err(Error::InvalidArgsCount("hset".to_owned()));
+    }
+    conn.db().get_map(
+        &args[1],
+        |v| match v {
+            Value::Hash(h) => {
+                let mut h = h.write();
+                let mut e: i64 = 0;
+                for i in (2..args.len()).step_by(2) {
+                    if h.insert(args[i].clone(), args[i + 1].clone()).is_none() {
+                        e += 1;
+                    }
+                }
+                Ok(e.into())
+            }
+            _ => Err(Error::WrongType),
+        },
+        || {
+            #[allow(clippy::mutable_key_type)]
+            let mut h = HashMap::new();
+            for i in (2..args.len()).step_by(2) {
+                h.insert(args[i].clone(), args[i + 1].clone());
+            }
+            let len = h.len() as i64;
+            conn.db().set(&args[1], h.into(), None);
+            Ok(len.into())
+        },
+    )
+}
+
+pub fn hsetnx(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    conn.db().get_map(
+        &args[1],
+        |v| match v {
+            Value::Hash(h) => {
+                let mut h = h.write();
+
+                if h.get(&args[2]).is_some() {
+                    Ok(0_i64.into())
+                } else {
+                    h.insert(args[2].clone(), args[3].clone());
+                    Ok(1_i64.into())
+                }
+            }
+            _ => Err(Error::WrongType),
+        },
+        || {
+            #[allow(clippy::mutable_key_type)]
+            let mut h = HashMap::new();
+            for i in (2..args.len()).step_by(2) {
+                h.insert(args[i].clone(), args[i + 1].clone());
+            }
+            let len = h.len() as i64;
+            conn.db().set(&args[1], h.into(), None);
+            Ok(len.into())
+        },
+    )
+}
+
+pub fn hstrlen(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    match conn.db().get(&args[1]) {
+        Value::Hash(h) => Ok(if let Some(v) = h.read().get(&args[2]) {
+            (v.len() as i64).into()
+        } else {
+            0_i64.into()
+        }),
+        Value::Null => Ok(0_i64.into()),
+        _ => Err(Error::WrongType),
+    }
+}
+
+pub fn hvals(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
+    match conn.db().get(&args[1]) {
+        Value::Hash(h) => {
+            let mut ret = vec![];
+
+            for value in h.read().values() {
+                ret.push(Value::Blob(value.clone()));
+            }
+
+            Ok(ret.into())
+        }
+        Value::Null => Ok(Value::Array(vec![])),
+        _ => Err(Error::WrongType),
+    }
+}

src/cmd/mod.rs

@@ -1,3 +1,4 @@
 pub mod client;
+pub mod hash;
 pub mod key;
 pub mod string;

src/cmd/string.rs

@@ -10,12 +10,12 @@ pub fn incr(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
 }
 
 pub fn incr_by(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
-    let by: i64 = (&Value::Blob(args[2].to_owned())).try_into()?;
+    let by: i64 = bytes_to_number(&args[2])?;
     conn.db().incr(&args[1], by)
 }
 
 pub fn incr_by_float(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
-    let by: f64 = (&Value::Blob(args[2].to_owned())).try_into()?;
+    let by: f64 = bytes_to_number(&args[2])?;
     conn.db().incr(&args[1], by)
 }
 
@@ -47,7 +47,7 @@ pub fn mget(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
 pub fn set(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
     Ok(conn
         .db()
-        .set(&args[1], &Value::Blob(args[2].to_owned()), None))
+        .set(&args[1], Value::Blob(args[2].to_owned()), None))
 }
 
 pub fn setex(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
@@ -59,7 +59,7 @@ pub fn setex(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {
 
     Ok(conn
         .db()
-        .set(&args[1], &Value::Blob(args[2].to_owned()), Some(ttl)))
+        .set(&args[1], Value::Blob(args[2].to_owned()), Some(ttl)))
 }
 
 pub fn strlen(conn: &Connection, args: &[Bytes]) -> Result<Value, Error> {

src/connection.rs

@@ -21,7 +21,11 @@ impl Connections {
         self.connections.write().unwrap().remove(&id);
     }
 
-    pub fn new_connection(self: &Arc<Connections>, db: Arc<Db>, addr: SocketAddr) -> Arc<Connection> {
+    pub fn new_connection(
+        self: &Arc<Connections>,
+        db: Arc<Db>,
+        addr: SocketAddr,
+    ) -> Arc<Connection> {
         let mut id = self.counter.write().unwrap();
 
         let conn = Arc::new(Connection {
@@ -87,7 +91,10 @@ impl Connection {
     pub fn info(&self) -> String {
         format!(
             "id={} addr={} name={:?} db={}\r\n",
-            self.id, self.addr, self.name.read().unwrap(), self.current_db
+            self.id,
+            self.addr,
+            self.name.read().unwrap(),
+            self.current_db
         )
     }
 }

src/db/mod.rs

@@ -146,6 +146,24 @@ impl Db {
         matches.into()
     }
 
+    pub fn get_map<F1, F2>(&self, key: &Bytes, found: F1, not_found: F2) -> Result<Value, Error>
+    where
+        F1: FnOnce(&Value) -> Result<Value, Error>,
+        F2: FnOnce() -> Result<Value, Error>,
+    {
+        let entries = self.entries[self.get_slot(key)].read().unwrap();
+        let entry = entries.get(key).filter(|x| x.is_valid()).map(|e| e.get());
+
+        if let Some(entry) = entry {
+            found(entry)
+        } else {
+            // drop lock
+            drop(entries);
+
+            not_found()
+        }
+    }
+
     pub fn get(&self, key: &Bytes) -> Value {
         let entries = self.entries[self.get_slot(key)].read().unwrap();
         entries
@@ -181,14 +199,14 @@ impl Db {
         })
     }
 
-    pub fn set(&self, key: &Bytes, value: &Value, expires_in: Option<Duration>) -> Value {
+    pub fn set(&self, key: &Bytes, value: Value, expires_in: Option<Duration>) -> Value {
         let mut entries = self.entries[self.get_slot(key)].write().unwrap();
         let expires_at = expires_in.map(|duration| Instant::now() + duration);
 
         if let Some(expires_at) = expires_at {
             self.expirations.lock().unwrap().add(key, expires_at);
         }
-        entries.insert(key.clone(), Entry::new(value.clone(), expires_at));
+        entries.insert(key.clone(), Entry::new(value, expires_at));
         Value::OK
     }
 
@@ -231,7 +249,7 @@ mod test {
     #[test]
     fn incr_wrong_type() {
         let db = Db::new(100);
-        db.set(&bytes!(b"num"), &Value::Blob(bytes!("some string")), None);
+        db.set(&bytes!(b"num"), Value::Blob(bytes!("some string")), None);
 
         let r = db.incr(&bytes!("num"), 1);
 
@@ -243,7 +261,7 @@ mod test {
     #[test]
     fn incr_blob_float() {
         let db = Db::new(100);
-        db.set(&bytes!(b"num"), &Value::Blob(bytes!("1.1")), None);
+        db.set(&bytes!(b"num"), Value::Blob(bytes!("1.1")), None);
 
         assert_eq!(Value::Float(2.2), db.incr(&bytes!("num"), 1.1).unwrap());
         assert_eq!(Value::Blob(bytes!("2.2")), db.get(&bytes!("num")));
@@ -252,7 +270,7 @@ mod test {
     #[test]
     fn incr_blob_int_float() {
         let db = Db::new(100);
-        db.set(&bytes!(b"num"), &Value::Blob(bytes!("1")), None);
+        db.set(&bytes!(b"num"), Value::Blob(bytes!("1")), None);
 
         assert_eq!(Value::Float(2.1), db.incr(&bytes!("num"), 1.1).unwrap());
         assert_eq!(Value::Blob(bytes!("2.1")), db.get(&bytes!("num")));
@@ -261,7 +279,7 @@ mod test {
     #[test]
     fn incr_blob_int() {
         let db = Db::new(100);
-        db.set(&bytes!(b"num"), &Value::Blob(bytes!("1")), None);
+        db.set(&bytes!(b"num"), Value::Blob(bytes!("1")), None);
 
         assert_eq!(Value::Integer(2), db.incr(&bytes!("num"), 1).unwrap());
         assert_eq!(Value::Blob(bytes!("2")), db.get(&bytes!("num")));
@@ -284,15 +302,11 @@ mod test {
     #[test]
     fn del() {
         let db = Db::new(100);
-        db.set(
-            &bytes!(b"expired"),
-            &Value::OK,
-            Some(Duration::from_secs(0)),
-        );
-        db.set(&bytes!(b"valid"), &Value::OK, None);
+        db.set(&bytes!(b"expired"), Value::OK, Some(Duration::from_secs(0)));
+        db.set(&bytes!(b"valid"), Value::OK, None);
         db.set(
             &bytes!(b"expiring"),
-            &Value::OK,
+            Value::OK,
             Some(Duration::from_secs(5)),
         );
 
@@ -310,15 +324,11 @@ mod test {
     #[test]
     fn ttl() {
         let db = Db::new(100);
-        db.set(
-            &bytes!(b"expired"),
-            &Value::OK,
-            Some(Duration::from_secs(0)),
-        );
-        db.set(&bytes!(b"valid"), &Value::OK, None);
+        db.set(&bytes!(b"expired"), Value::OK, Some(Duration::from_secs(0)));
+        db.set(&bytes!(b"valid"), Value::OK, None);
         db.set(
             &bytes!(b"expiring"),
-            &Value::OK,
+            Value::OK,
             Some(Duration::from_secs(5)),
         );
 
@@ -334,7 +344,7 @@ mod test {
     #[test]
     fn purge_keys() {
         let db = Db::new(100);
-        db.set(&bytes!(b"one"), &Value::OK, Some(Duration::from_secs(0)));
+        db.set(&bytes!(b"one"), Value::OK, Some(Duration::from_secs(0)));
         // Expired keys should not be returned, even if they are not yet
         // removed by the purge process.
         assert_eq!(Value::Null, db.get(&bytes!(b"one")));
@@ -349,12 +359,12 @@ mod test {
     #[test]
     fn replace_purge_keys() {
         let db = Db::new(100);
-        db.set(&bytes!(b"one"), &Value::OK, Some(Duration::from_secs(0)));
+        db.set(&bytes!(b"one"), Value::OK, Some(Duration::from_secs(0)));
         // Expired keys should not be returned, even if they are not yet
         // removed by the purge process.
         assert_eq!(Value::Null, db.get(&bytes!(b"one")));
 
-        db.set(&bytes!(b"one"), &Value::OK, Some(Duration::from_secs(5)));
+        db.set(&bytes!(b"one"), Value::OK, Some(Duration::from_secs(5)));
         assert_eq!(Value::OK, db.get(&bytes!(b"one")));
 
         // Purge should return 0 as the expired key has been removed already

src/dispatcher.rs

@@ -22,6 +22,83 @@ fn do_command(_conn: &Connection, _args: &[Bytes]) -> Result<Value, Error> {
 }
 
 dispatcher! {
+    hash {
+        hdel {
+            cmd::hash::hdel,
+            [""],
+            -2,
+        },
+        hexists {
+            cmd::hash::hexists,
+            [""],
+            3,
+        },
+        hget {
+            cmd::hash::hget,
+            [""],
+            3,
+        },
+        hgetall {
+            cmd::hash::hgetall,
+            [""],
+            2,
+        },
+        hincrby {
+            cmd::hash::hincrby::<i64>,
+            [""],
+            4,
+        },
+        hincrbyfloat {
+            cmd::hash::hincrby::<f64>,
+            [""],
+            4,
+        },
+        hkeys {
+            cmd::hash::hkeys,
+            [""],
+            2,
+        },
+        hlen {
+            cmd::hash::hlen,
+            [""],
+            2,
+        },
+        hmget {
+            cmd::hash::hmget,
+            [""],
+            -3,
+        },
+        hmset {
+            cmd::hash::hset,
+            [""],
+            -3,
+        },
+        hrandfield {
+            cmd::hash::hrandfield,
+            [""],
+            -2,
+        },
+        hset {
+            cmd::hash::hset,
+            [""],
+            -4,
+        },
+        hsetnx {
+            cmd::hash::hsetnx,
+            [""],
+            -4,
+        },
+        hstrlen {
+            cmd::hash::hstrlen,
+            [""],
+            3,
+        },
+        hvals {
+            cmd::hash::hvals,
+            [""],
+            2,
+        },
+    },
     keys {
         del {
             cmd::key::del,

src/error.rs

@@ -6,6 +6,7 @@ pub enum Error {
     InvalidArgsCount(String),
     Protocol(String, String),
     WrongArgument(String, String),
+    Syntax,
     NotANumber,
     WrongType,
 }
@@ -21,13 +22,14 @@ impl From<Error> for Value {
             Error::CommandNotFound(x) => format!("unknown command `{}`", x),
             Error::InvalidArgsCount(x) => format!("wrong number of arguments for '{}' command", x),
             Error::Protocol(x, y) => format!("Protocol error: expected '{}', got '{}'", x, y),
-            Error::NotANumber => "value is not an integer or out of range".to_string(),
+            Error::NotANumber => "value is not an integer or out of range".to_owned(),
+            Error::Syntax => "syntax error".to_owned(),
             Error::WrongArgument(x, y) => format!(
                 "Unknown subcommand or wrong number of arguments for '{}'. Try {} HELP.",
                 y, x
             ),
             Error::WrongType => {
-                "Operation against a key holding the wrong kind of value".to_string()
+                "Operation against a key holding the wrong kind of value".to_owned()
             }
         };
 

src/server.rs

@@ -101,7 +101,5 @@ pub async fn serve(addr: String) -> Result<(), Box<dyn Error>> {
             }
             Err(e) => println!("error accepting socket; error = {:?}", e),
         }
-
-
     }
 }

src/value.rs

@@ -2,12 +2,44 @@ use crate::{error::Error, value_try_from, value_vec_try_from};
 use bytes::{Bytes, BytesMut};
 use redis_zero_protocol_parser::Value as ParsedValue;
 use std::{
+    collections::HashMap,
     convert::{TryFrom, TryInto},
     str::FromStr,
+    sync::{RwLock, RwLockReadGuard, RwLockWriteGuard},
 };
 
+#[derive(Debug)]
+pub struct LockedValue<T: Clone + PartialEq>(pub RwLock<T>);
+
+impl<T: Clone + PartialEq> Clone for LockedValue<T> {
+    fn clone(&self) -> Self {
+        Self(RwLock::new(self.0.read().unwrap().clone()))
+    }
+}
+
+impl<T: PartialEq + Clone> PartialEq for LockedValue<T> {
+    fn eq(&self, other: &LockedValue<T>) -> bool {
+        self.0.read().unwrap().eq(&other.0.read().unwrap())
+    }
+}
+
+impl<T: PartialEq + Clone> LockedValue<T> {
+    pub fn new(obj: T) -> Self {
+        Self(RwLock::new(obj))
+    }
+
+    pub fn write(&self) -> RwLockWriteGuard<'_, T> {
+        self.0.write().unwrap()
+    }
+
+    pub fn read(&self) -> RwLockReadGuard<'_, T> {
+        self.0.read().unwrap()
+    }
+}
+
 #[derive(Debug, PartialEq, Clone)]
 pub enum Value {
+    Hash(LockedValue<HashMap<Bytes, Bytes>>),
     Array(Vec<Value>),
     Blob(Bytes),
     String(String),
@@ -45,7 +77,7 @@ impl From<&Value> for Vec<u8> {
             Value::Err(x, y) => format!("-{} {}\r\n", x, y).into(),
             Value::String(x) => format!("+{}\r\n", x).into(),
             Value::OK => "+OK\r\n".into(),
-            _ => b"*-1\r\n".to_vec(),
+            _ => b"-WRONGTYPE Operation against a key holding the wrong kind of value\r\n".to_vec(),
         }
     }
 }
@@ -115,6 +147,12 @@ impl From<&str> for Value {
     }
 }
 
+impl From<HashMap<Bytes, Bytes>> for Value {
+    fn from(value: HashMap<Bytes, Bytes>) -> Value {
+        Value::Hash(LockedValue::new(value))
+    }
+}
+
 value_vec_try_from!(&str);
 
 impl From<String> for Value {