小编PL_*_*lek的帖子

我正在努力学习Rust,但我唯一要做的就是不停地试图将熟悉(对我而言)Java概念塞进其类型系统中.或者尝试使用Haskell概念等.

我想写一个有Player很多Resources 的游戏.每个人Resource都可以拥有一个Player:

struct Player {
    points: i32,
}

struct Resource<'a> {
    owner: Option<&'a Player>,
}

fn main() {
    let mut player = Player { points: 0 };
    let mut resources = Vec::new();
    resources.push(Resource {
        owner: Some(&player),
    });
    player.points = 30;
}

它不能编译,因为我不能将资源指向播放器,同时修改它:

error[E0506]: cannot assign to `player.points` because it is borrowed
  --> src/main.rs:15:5
   |
13 |         owner: Some(&player),
   |                      ------ borrow of `player.points` occurs here
14 |     });
15 |     player.points …

我正在写一个简单的游戏 - 俄罗斯方块.在我生命中我第一次使用函数式编程来实现这个目标,作为我选择Haskell的语言.然而,我被OOP和命令式思维所污染,害怕无意识地将这种心态运用到我的Haskell程序中.

在我游戏的某个地方,我需要有关于经过时间(计时器)和按下/向下键(键盘)的信息.转换为Haskell的SDL课程中使用的方法如下所示:

Main.hs

data AppData = AppData {
    fps :: Timer 
    --some other fields    
}

getFPS :: MonadState AppData m => m Timer
getFPS = liftM fps get

putFPS :: MonadState AppData m => Timer -> m ()
putFPS t = modify $ \s -> s { fps = t }

modifyFPSM :: MonadState AppData m => (Timer -> m Timer) -> m ()
modifyFPSM act = getFPS >>= act >>= putFPS

Timer.hs

data Timer = Timer { …

我正在努力了解FRP和Netwire.我最好的实用知识来源是这篇文章,但它有点过时,因为它是用Netwire 4编写的,我使用的是5.0版.我希望玩家控制正方形,从屏幕边缘反弹.

根据这篇文章,我有这个:

acceleration :: (Monad m, Monoid e) => Wire s e m (Set SDL.Keysym) Double
acceleration  =  pure (-80) . when (keyDown SDL.SDLK_LEFT)
                    <|> pure 80 . when (keyDown SDL.SDLK_RIGHT)
                    <|> pure 0

velocity :: (Monad m, HasTime t s, Monoid e) => Wire s e m (Double, Bool) Double
velocity = integralWith limit 0
    where limit collision v = let newV = if collision then -v else v in clampMax maxV newV


challenge2 :: (MonadFix …

为什么这不编译:

fn main() {
    let mut b = Box::new(Vec::new());
    b.push(Vec::new());
    b.get_mut(0).unwrap().push(1);
}

虽然这样做:

fn main() {
    let a = Box::new(Vec::new());
    let mut b = *a;
    b.push(Vec::new());
    b.get_mut(0).unwrap().push(1);
}

这也是:

fn main() {
    let mut b = Vec::new();
    b.push(Vec::new());
    b.get_mut(0).unwrap().push(Vec::new());
    b.get_mut(0).unwrap().get_mut(0).unwrap().push(1)
}

第一和第三个对我来说是概念上是相同的- Box一中Vec的TOR Vec整数的职责范围和Vec的TOR Vec的TOR Vec整数的职责范围,但最后一个导致每个向量是可变的,而第一个使内部矢量不变.