小编Uko*_* Ra的帖子

我有一个通用接口和一个实现它的类:

import java.util.Arrays;

interface Interface<T> {
    void doSomething(T element);
}

class StringImpl implements Interface<String> {
    @Override
    public void doSomething(String element) {
        System.out.println("StringImpl: doSomething");
    }
}

public class Main {
    public static void main(String... args) {
        System.out.println(Arrays.toString(StringImpl.class.getDeclaredMethods()));
    }
}

结果是

[public void com.ra.StringImpl.doSomething(java.lang.String), 
public void com.ra.StringImpl.doSomething(java.lang.Object)]

但实际上,我只想要实现版本:

public void com.ra.StringImpl.doSomething(java.lang.String)

你有任何方便的方法来实现它吗？

为编写异步路由器时，我无法处理异步功能hyper。

这段代码：

use std::collections::HashMap;
use std::future::Future;

type BoxedResult<T> = Result<T, Box<dyn std::error::Error + Send + Sync>>;
type CalcFn = Box<dyn Fn(i32, i32) -> dyn Future<Output = BoxedResult<i32>>>;

async fn add(a: i32, b: i32) -> BoxedResult<i32> {
    Ok(a + b)
}

async fn sub(a: i32, b: i32) -> BoxedResult<i32> {
    Ok(a - b)
}

fn main() {
    let mut map: HashMap<&str, CalcFn> = Default::default();
    map.insert("add", Box::new(add));
    map.insert("sub", Box::new(sub));

    println!("map size: {}", map.len());
}

生成以下编译器错误：

use std::collections::HashMap;
use std::future::Future;

type …

假设我有一个带有一些业务逻辑的 Java 类：

package examples;

import java.util.List;
import java.util.Map;

public class Inner {
    public void consume(Map<Integer, List<Double>> map) {
        map.forEach((k, v) -> {
            System.out.println("Key: " + k);
            v.forEach(i -> System.out.println("  item: " + i));
        });
    }
}

现在我想编写一个高性能的、尽可能原生的Scala 包装器（因为这个包装器可能会被高频调用），所以：

第一次尝试

package examples

class Wrapper(val asJava: Inner) extends AnyVal {
  implicit def consume(map: Map[Int, List[Double]]): Unit = asJava.consume(map)
}

但得到错误：

[error]  found   : Map[Int,List[Double]]               (in scala.collection.immutable)
[error]  required: Map[Integer,java.util.List[Double]] (in java.util)
[error]   implicit def consume(map: Map[Int, List[Double]]): Unit = …