Comments (8)
Should this be done via specialization?
Something like:
impl <K, V, S> Ordermap<K, V, S> {
default fn get_pair_mut(&mut self, key: &Q) -> (&K, &mut V) { .. }
}
impl <K: MutableHashMarker, V, S> Ordermap<K, V, S> {
fn get_pair_mut(&mut self, key: &Q) -> (&mut K, &mut V) { .. }
}
I suspect inherent impl specialization is a long way off, but ultimately I much prefer only having one method name.
from indexmap.
The point of a trait would be to provide the feature, but have it a bit out of the way, so reduce misuses of it.
from indexmap.
Oh I see the role of that marker trait now. I don't think that's a viable thing to do for technical reasons: get_pair_mut
would then vary its signature in a way that's not compatible with Rust's usual trait rules (it would be similar to a C++ templaty thing, that expands to something different for different input types).
from indexmap.
There are several ways to accomplish something close to it.
You could use associated types:
fn get_pair_mut(&mut self, key: &Q) -> (KeyReference::Type, &'a mut V)
where K: KeyReference
impl<'a, K> KeyReference<'a> for K { default type Type = &'a K; }
impl<'a, K:MutableHashMarker> KeyReference<'a> for K { type Type = &'a mut K; }
Also just realized you could do it without specialization if you use a wrapper:
struct KeyWrapper<'a, K: 'a>(&'a mut K);
trait MutableHashMarker{}
impl<'a, K> Deref for KeyWrapper<'a, K> {
type Target = K;
fn deref(&self) -> &K { self.0 }
}
impl<'a, K: MutableHashMarker> DerefMut for KeyWrapper<'a, K> {
fn deref_mut(&mut self) -> &mut K { self.0 }
}
impl<'a, K> Into<&'a K> for KeyWrapper<'a, K> {
fn into(self) -> &'a K { self.0 }
}
impl<'a, K: MutableHashMarker> Into<&'a mut K> for KeyWrapper<'a, K> {
fn into(self) -> &'a mut K { self.0 }
}
fn get_pair_mut(&mut self, key: &Q) -> (KeyWrapper<K>, &mut V)
from indexmap.
I've already implemented KeyWrapper once. (I promise). I didn't commit to the idea.
from indexmap.
In general I think each advanced use of the type system has a cost and it has to have a value that offsets that :) Sometimes the simple is the best.
from indexmap.
I think it'll be rather difficult to come up with good_method_name
. get_pair_mut_key_mut
doesn't really roll of the proverbial tongue.
Even with a good name, having two functions still seems less intuitive to me.
from indexmap.
It is possible to avoid using a wrapper structure, and achieve almost the same thing using impl Trait
Here's a small demo:
#![feature(conservative_impl_trait)]
use std::ops::Deref;
trait MutableHashMarker{}
trait KeyRef<'a, K>: Deref<Target=K> {
fn as_mut(self) -> &'a mut K
where K: MutableHashMarker;
}
impl<'a, K> KeyRef<'a, K> for &'a mut K {
fn as_mut(self) -> &'a mut K
where K: MutableHashMarker { self }
}
struct OrderMap<K, V, S>(K, V, S);
impl <K, V, S> OrderMap<K, V, S> {
fn get_pair_mut<'a, Q>(&'a mut self, _key: &Q) -> (impl KeyRef<'a, K>, &'a mut V) {
(&mut self.0, &mut self.1)
}
}
struct MutKey(i32);
impl MutableHashMarker for MutKey{}
fn main() {
{
let mut v = OrderMap(MutKey(1i32), (), ());
let (k, _) = v.get_pair_mut(&0);
k.as_mut();
}
{
let mut v = OrderMap(1i32, (), ());
let (k, _) = v.get_pair_mut(&0);
let i: i32 = *k;
// k.as_mut(); // Error: the trait `MutableHashMarker` is not implemented for `i32`
}
}
from indexmap.
Related Issues (20)
- `binary_search` and `partition_point` on `Slice` HOT 4
- Feature request: Add Index<usize> to Keys HOT 1
- Implement (behind a feature branch) the Merge Crate HOT 4
- IndexMap doesn't implement `Hash` HOT 1
- Compilation bug HOT 1
- Organization / repo home HOT 12
- Doc link on crates.io is dead. HOT 3
- Kaspersky detected the indexmap build-script exe as malware (false positive) HOT 1
- MutableKeys for IndexSet HOT 2
- implement get_many_mut HOT 1
- serde_json::to_string serializes (key, value) HOT 3
- Request: add example to README
- Thanks :)
- Insert into Indexmap randomly fails HOT 9
- Expanding mut key API HOT 2
- Feature request: join two or more IndexMap HOT 2
- Request: Random access of key/value pairs HOT 2
- range end index 2 out of range for slice of length 1 HOT 20
- Feature request: `Into<std::collections::HashMap>` HOT 1
- `Clone` for into-iterators HOT 4
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.
from indexmap.