小编cib*_*en1的帖子

我正在考虑写作的方法

class MyClass {
  @Get
  @Set
  protected int aValue;
}

然后,自动为类生成get_aValue()和set_AValue()方法.

我发现了这些可能性:

1a)在编译时.使用注释处理器分别处理MyClass.java,然后编写一个新的MyClass.java,最后使用后者(用原文替换)与.java的其余部分

1b)在编译时.使用注释处理器生成一个MyClassGenerated.java文件,其中包含一个新类(使用get/set方法),这个类是原始MyClass的子类.

2)在运行时.使用java.lang.instrument和外部工具(如BCEL)在MyClass.class中编写新代码.

嗯,问题是:考虑到我尽可能不想使用第三方库(如lombok项目或BCEL)

b)您会使用哪种方法？

我想我会用1a)因为

1b)不干净(程序的其余部分应该使用MyClassGeneradted而不是原始的MyClass,尽管它可能仅仅是名称问题)

2)真的很难(对我来说,至少).

克隆ArrayList(Vector替换)的我可能是天真的解决方案

ArrayList<Double> alBis = (ArrayList<Double>) alOriginal.clone();

考虑到因为数组包含不可变的双打,我不需要克隆它们,而只需要克隆容器.

当clone()返回一个Object时,我把它放在那里,然后-Xlint抱怨它是一个未经检查的强制转换.

所以现在怎么办？用supressWarnings忽略它？创建一个新的ArrayList并使用compact来复制原始元素？任何类似于Arrays.copyOf()的库方法？

我阅读了未经检查的投射警告,但接受的方式是令人难以置信的复杂.

我(试图)在Haskell中学习可变状态.为了简单起见,我定义了

data Car = Car { position :: Int }

和

move :: Car -> Int -> Car
move c n =  Car { position = n + (position c) }

因此,move是一个"纯粹"的功能,代表了汽车向另一个汽车的过渡.

我认为我需要将一辆Car放在一个可变的变量中,这样我才能拥有当前位置(在对汽车进行一些动作之后).因此,我定义(我希望这是方法,否则纠正我)以下

type Parking = IORef Car -- holds a car

newParking :: Car -> IO Parking
newParking = newIORef 

以及琐碎getCar :: Parking -> IO Car和setCar :: Parking -> Car -> IO ()功能.

上面的代码似乎没问题.

问题:

我可以定义一个将任何纯函数move :: Car -> Int …

在这个问题中,这似乎可以解决lambda的情况.但那个是2011年的答案,我正在寻找一个普遍的案例:lambdas,常规函数和函子.并且,如果可能的话,通过最现代的c ++语言添加.(注意:) g++ -std=c++1y test.cpp.

所以,给定一个函数(或一个lambda),我试图找出它的返回类型是什么.例如,声明一个变量(简化的情况).

using namespace std;

template<typename F>
void test (F h) {
  // any of the following should be equivalent to int a; int b; int c;
  decltype(h) a; // <<<<< wrong
  result_of(h) b; // <<<<<< wrong
  result_of<decltype(h)> c; // <<<<<< wrong
}

int a_function (int i)  { 
  return 2*i; 
}

int main ()  {
  test (a_function);
}

谢谢.

只是测试/学习用C++重写|运算符来编写管道,以下程序无法编译:

忽略二进制表达式候选模板的无效操作数:...无法将'bitset'与'vector'匹配

似乎编译器正在尝试使用标准| 定义.该代码使用显式调用和显式类型参数集.

// g++ -std=c++11 Pipeline.cpp 
#include <iostream>
#include <vector>

// ..............................................................
// ..............................................................
std::string dup (std::string s) {
  return s + s;
}

// ..............................................................
// ..............................................................
template <typename TI, typename TO>
std::vector<TO> operator | (const std::vector<TI> & in, std::function<TO(TI)> f) {
  std::vector<TO> out;
  for (auto i : in) {
    out.push_back ( f(i) );
  }
  return out;
}

// ..............................................................
// ..............................................................
int main () {
  std::cout << " hello " << std::endl;

  std::vector<std::string> vs …

根据 All about monads

Monad值(Reader monad)是从环境到值的函数.绑定函数应用于绑定值,并且都可以访问共享环境.

但是,为什么有必要在这个monad中使用一个函数(而不是,例如,两个变量,一个用于环境,一个用于值)？

这篇文章提出了案件的问题!!.接受的答案告诉我们,您实际在做的是创建一个新功能!!,然后您应该避免导入标准功能.

但是,如果将新功能应用于不同类型而不是标准功能,为什么要这样做呢？编译器是否能够根据其参数选择正确的编译器？是否有任何编译器标志允许这个？

例如,如果*没有定义[Float] * Float

为什么编译器会哭

>  Ambiguous occurrence *
>  It could refer to either `Main.*', defined at Vec.hs:4:1
>                          or `Prelude.*',

对于此代码:

(*) :: [Float] -> Float -> [Float]
(*) as k = map (\a -> a*k) as  -- here: clearly Float*Float


r = [1.0, 2.0, 3.0] :: [Float]

s = r * 2.0 -- here: clearly [Float] * Float

main = do
     print r
     print s

只是（模拟）多重继承是混合的唯一优点：

 Object.assign( MyClassA.prototype, MyMixinB )

与继承

 class MyClass extends MyClassB {

 // MyClassB = class version of MyMixinB

在 ES6 JavaScript 中？

谢谢

我想知道这个关于期货的老问题的答案是否仍然适用于更新的语言结构async/await。似乎是这样，因为下面的代码打印：

hello 
good bye 
hello

虽然指南说

futures::join 宏可以等待多个不同的 future 完成，同时执行它们。

显然，对于许多其他异步系统（例如， node.js）而言，这是对预期行为的转移sleep。

有什么根本原因吗？

hello 
good bye 
hello

添加：实际线程预期的行为 (I)

fn main() {

    let fut1 = do_async( move || {
        println!( "hello" );
        thread::sleep( Duration::from_millis( 3000 ) );
        println!( "good bye" );
    });

    let fut2 = do_async( move || {
        println!( "hello" );
    });

    fut1();
    fut2();

}

use std::time::Duration;
use std::thread;

async fn sayHiOne() {
    println!( " hello " );
    thread::sleep( Duration::from_millis( …

我不明白为什么 Rust在这段代码中抱怨（“不能借用为不可变的，因为也借用为可变的.len()”）（即使考虑到这是一个“常量/无害”的函数）：

fn main() {
    
    let mut xs1: [i32; 5] = [ 10, 20, 30, 40, 50];

    let (slice1, slice2) = xs1.split_at_mut( (xs1.len()/2) ); // <----- ERROR

    println!( "{:?}", slice1 );
    println!( "{:?}", slice2 );

    

} // ()

虽然拆分版本很好：

let aux = xs1.len()/2;
let (slice1, slice2) = xs1.split_at_mut( aux );

这里面的道理是什么？

也许我错了，但我总是认为这两个表达式是“数学上等价的”。不仅len()应该是一个const方法，而且输入参数也split_at_mut()应该是const（用 C++ 的说法）。

八年后仍抱有这个疑问？