小编osh*_*hko的帖子

我正在学习Scala,我有一个Java项目要迁移到Scala.我想通过逐个重写类并检查新类没有破坏项目来迁移它.

这个Java项目使用了很多java.util.List和java.util.Map.在新的Scala类中,我想使用Scala List并Map拥有漂亮的Scala代码.

问题是新的类(那些在Scala中是wtitten)没有与现有的Java代码无缝集成:Java需要java.util.List,Scala需要它自己的代码scala.List.

以下是该问题的简化示例.有Main,Logic,Dao类.他们互相称呼:Main - > Logic - > Dao.

public class Main {
    public void a() {
        List<Integer> res = new Logic().calculate(Arrays.asList(1, 2, 3, 4, 5));
    }
}

public class Logic {
    public List<Integer> calculate(List<Integer> ints) {
        List<Integer> together = new Dao().getSomeInts();
        together.addAll(ints);
        return together;
    }
}

public class Dao {
    public List<Integer> getSomeInts() {
        return Arrays.asList(1, 2, 3); …

我开发了一个2D射击游戏,有很多物体和积极的滚动.

问题:哪种方式更好？

选择1 - 使用原生Flash渲染:

• 从Bitmap派生游戏对象,使用现有的x,y,width,height,bitmapData
• 将所有对象作为子UIComponent.addChild(...)添加到sccreen
• 使用"scrollRect"剪辑可见区域

选择2 - 使用"bitmap + copyPixels"编写自定义渲染

• 使用自己的游戏对象x,y,width,height,bitmapData
• 将Bitmap添加到屏幕,从中获取bitmapData
• 重新绘制每个ENTER_FRAME:bitmapData.lock(),迭代游戏对象和copyPixels()到bitmapData,然后bitmapData.unlock()
• 自定义剪裁:不渲染屏幕对象

在这个问题中有人抱怨"bitmap + copyPixels()"很慢.

实验:我已经实现了两种技术:

• main_1.swf - 原生
• main_2.swf - 自定义

请尝试一下,告诉哪一个更好(更快,更顺畅,占用更少的CPU).

等到至少有250个敌人(屏幕上方的计数器).
更新:尝试打开任务管理器(或$ top)并查看总体CPU使用情况

更新2:我已经更改了代码,现在更快地生成了.

我正在学习Haskell Lazy IO.

我正在寻找一种优雅的方式来复制大文件(8Gb),同时将复制进度打印到控制台.

请考虑以下以静默方式复制文件的简单程序.

module Main where

import System
import qualified Data.ByteString.Lazy as B

main = do [from, to] <- getArgs
          body <- B.readFile from
          B.writeFile to body

Imgine有一个你想用于报告的回调函数:

onReadBytes :: Integer -> IO ()
onReadBytes count = putStrLn $ "Bytes read: " ++ (show count)

问题:如何将onReadBytes函数编织到Lazy ByteString中,以便在成功读取时调用它？或者如果这个设计不好,那么Haskell的做法是什么？

注意:回调的频率并不重要,可以每1024字节或每1Mb调用一次 - 不重要

答案:非常感谢camccann的答案.我建议完全阅读.

Bellow是基于camccann代码的代码版本,您可能会发现它很有用.

module Main where

import System
import System.IO
import qualified Data.ByteString.Lazy as B

main = do [from, to] <- getArgs
          withFile from ReadMode $ …

经过多年的OOP,我正在学习Haskell.

我正在写一个功能和状态很少的愚蠢的网络蜘蛛.
我不知道如何在FP世界中做到这一点.

在OOP世界中,这个蜘蛛可以像这样设计(按用法):

Browser b = new Browser()
b.goto(“http://www.google.com/”)

String firstLink = b.getLinks()[0]

b.goto(firstLink)
print(b.getHtml())

此代码加载http://www.google.com/,然后"点击"第一个链接,加载第二页的内容,然后打印内容.

class Browser {
   goto(url: String) : void // loads HTML from given URL, blocking
   getUrl() : String // returns current URL
   getHtml() : String // returns current HTML
   getLinks(): [String] // parses current HTML and returns a list of available links (URLs)

   private _currentUrl:String
   private _currentHtml:String
}

它可能同时拥有2个或"浏览器",具有自己独立的状态:

Browser b1 = new Browser()
Browser b2 = new Browser()

b1.goto(“http://www.google.com/”)
b2.goto(“http://www.stackoverflow.com/”)

print(b1.getHtml()) …

哪一个更快？为什么？

var messages:Array = [.....]

// 1 - for
var len:int = messages.length;
for (var i:int = 0; i < len; i++) {
    var o:Object = messages[i];
    // ...
}

// 2 - foreach
for each (var o:Object in messages) {
    // ...
}

我是一名学习Haskell的Java程序员.
我在一个小型网络应用程序上工作,该应用程序使用Happstack并通过HDBC与数据库进行通信.

我编写了select和exec函数,我就像这样使用它们:

module Main where

import Control.Exception (throw)

import Database.HDBC
import Database.HDBC.Sqlite3 -- just for this example, I use MySQL in production

main = do
    exec "CREATE TABLE IF NOT EXISTS users (name VARCHAR(80) NOT NULL)" []

    exec "INSERT INTO users VALUES ('John')" []
    exec "INSERT INTO users VALUES ('Rick')" []

    rows <- select "SELECT name FROM users" []

    let toS x = (fromSql x)::String
    let names = map (toS . head) rows

    print names …

我在2D射击游戏上工作,屏幕上有许多移动物体(子弹等).

我使用BitmapData.copyPixels(...)将整个屏幕渲染到缓冲区:BitmapData.然后我从"缓冲区""copyPixels"到屏幕:BitmapData.帧率为60.

private var bitmap:Bitmap = new Bitmap();
private var buffer:Bitmap = new Bitmap();

private function start():void {
    addChild(bitmap);
}

private function onEnterFrame():void {
    // render into "buffer"
    // copy "buffer" -> "bitmap"
}

问题是精灵正在撕裂:精灵的某些部分水平移动.

它看起来像是关闭了VSYNC的PC游戏.

有人解决了这个问题吗？

更新:问题不是关于性能,而是关于摆脱屏幕撕裂.

[!]更新:我已经创建了另一个问题,在这里您可以尝试两种实现:使用Flash方式或BitmapData + copyPixels()

是否有一种优雅的方式来阻止跑步挡？

(没有引入标志并用支票/分支污染代码)

(ns example
  (:require-macros [cljs.core.async.macros :refer [go]])
  (:require        [cljs.core.async        :refer [<! timeout]]))

(defn some-long-task []
  (go
    (println "entering")

    ; some complex long-running task (e.g. fetching something via network)
    (<! (timeout 1000)) 
    (<! (timeout 1000))
    (<! (timeout 1000))
    (<! (timeout 1000))

    (println "leaving")))

; run the task
(def task (some-long-task))

; later, realize we no longer need the result and want to cancel it 
; (stop! task)

我有十几种这样的新类型：

newtype MyBool = MyBool Bool
newtype MyInt  = MyInt  Int

我想重用现有实例：

instance MArray IOUArray Int IO         where ...
instance MArray (STUArray s) Int (ST s) where ...

实现这些实例并拥有所有样板代码是我最不想要的。

我发现了一些看起来非常接近我想要实现的目标：

{-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving #-}

deriving instance MArray IOUArray MyInt IO      
deriving instance MArray (STUArray s) MyInt (ST s)  

但是，它失败了：

Can't make a derived instance of ‘MArray IOUArray MyInt IO’
    (even with cunning GeneralizedNewtypeDeriving):
    cannot eta-reduce the representation type enough
In the stand-alone deriving instance for ‘MArray IOUArray MyInt IO’ …

我正在Haskell(pub/sub + storage)中处理文件支持的队列.

我的想法是有一个带有W + R + R + R句柄的日志文件:

• pub:一个W句柄,用于写/附加
• sub:多个R用于拖尾和随机搜索过去的条目

但是,打开两个句柄(R + W)到同一个文件不适用于GHC:

#!/usr/bin/env stack
-- stack --resolver lts-13.0 --install-ghc runghc

module Main where

import System.IO

main :: IO ()
main = do
  let path = "file.txt"

  _ <- openFile path WriteMode
  _ <- openFile path ReadMode -- throws *** Exception: file.txt: openFile: resource busy (file is locked)
  _ <- openFile path ReadMode
  _ <- openFile path ReadMode

  return ()

文件锁定部分开始承诺:

实现应该尽可能地强制执行,至少在本地Haskell进程,多读取器单写入器锁定文件.

......然后说:

也就是说,管理输入的同一文件上可能有许多句柄,或者管理输出的文件上只有一个句柄.

问题:

• 为什么会有这样的限制？
• 如何在Haskell/GHC中为文件设置W …

我观察到相同的fn会提供不同的性能，具体取决于它是放在使用该模块的同一模块中还是位于其旁边的模块中。任何想法可能是什么原因造成的？

这是函数：https : //github.com/oshyshko/polymodperf/blob/master/src/Main.hs#L41-L55

test :: MArray a t m => (t -> t) -> a Int t -> m ()
test f a =
    mapM_ (\ xy -> do
              v <- get a xy
              set a xy (f v))

          [ (x,y) | y <- [0..1000 - 1],
                    x <- [0..1000 - 1],
                    n <- [0..10]]
  where
    get :: MArray a e m => a Int e -> (Int, Int) -> m e
    get a (x,y) = readArray a …

我想用代码生成替换这个样板：

import qualified Y15.D01
import qualified Y15.D02
import qualified Y15.D03
import qualified Y15.D04
import qualified Y15.D05
import qualified Y15.D06HM
import qualified Y15.D06IO
import qualified Y15.D06ST
import qualified Y15.D07
import qualified Y15.D08
import qualified Y15.D09
import qualified Y15.D10
import qualified Y15.D11
import qualified Y15.D12
import qualified Y15.D13

...

days :: [(String, [String -> IO String])]
days =
    [ ("Y15.D01",  i2ios   [Y15.D01.solve1,   Y15.D01.solve2])
    , ("Y15.D02",  i2ios   [Y15.D02.solve1,   Y15.D02.solve2])
    , ("Y15.D03",  i2ios   [Y15.D03.solve1,   Y15.D03.solve2])
    , ("Y15.D04",  i2ios   [Y15.D04.solve1,   Y15.D04.solve2])
    , ("Y15.D05",  i2ios   [Y15.D05.solve1, …