小编dav*_*420的帖子

我想为树结构实现一个通用层次结构,以后可以用一种与实现无关的方式来描述树上的通用算法.

我从这个层次结构开始:

interface BinaryTree<Node> {
    Node left(Node);
    bool hasLeft(Node);

    Node right(Node);
    bool hasRight(Node);
}

interface BinaryTreeWithRoot<Node> : BinaryTree<Node> {
    Node root();
}

interface BinaryTreeWithParent<Node> : BinaryTree<Node> {
    Node parent(Node);
    bool hasParent(Node);
}

现在,基本上我希望能够以通用的方式实现子树的概念:对于每个类T:BinaryTree,我想要一个'类'子树(T),它提供相同的T功能(所以它必须来自它),并重写root()功能.

像这样的东西:

class Subtree<T, Node> : T, BinaryTreeWithRoot<Node> 
    where T : BinaryTree<Node>
{
    T reference;
    Node root;

    void setRoot(Node root) {
        this.root = root;
    }

    override Node BinaryTreeWithRoot<Node>::root() {
        return this.root;
    }

    // Now, inherit all the functionality of T, so an instance of this class can be …

我想创建一个模块,并将其加载到haskell库中.我可以使用haskell-platform的工具与ubuntu 11或Windows 7一起工作.这是我的模块:

module Pkr.Element(..) where

import Char

data Card = Card Int deriving (Eq)

seme :: Card -> Int
seme (Card x) = mod (div x 13) 4

label :: Card -> Int
label (Card x) = mod x 13

instance Ord Card where
(>) x y     |ix == iy       = False
        |ix == 0        = True
        |iy == 0        = False
        | otherwise     = (ix > iy)
        where 
        ix = label x
        iy = label y

instance Show …

我正在处理一组消息对象,每个消息对象都有一个与之对应的唯一标识符.每条消息都可以从Map或ByteBuffer构建(消息是二进制的,但我们知道如何与二进制表示进行转换).

构建这些消息的当前实现大致如下:

public static Message fromMap(int uuid, Map<String, Object> fields) {
    switch (uuid) {
      case FIRST_MESSAGE_ID:
        return new FirstMessage(fields);
        .
        .
        .
      default:
          // Error
          return null;
    }
}

public static Message fromByteBuffer(int uuid, ByteBuffer buffer) {
    switch (uuid) {
      case FIRST_MESSAGE_ID:
        return new FirstMessage(buffer);
        .
        .
        .
      default:
          // Error
          return null;
    }
}

现在,Josh Bloch的Effective Java讨论了第1项:考虑静态工厂方法而不是构造函数,这似乎是这个模式有用的地方(客户端不直接访问Message子类型的构造函数;相反,他们通过这个方法).但我不喜欢这样一个事实,即我们必须记住更新两个switch语句(违反DRY原则).

我很欣赏任何有关实现这一目标的最佳方法的见解; 我们不是缓存对象(每次调用fromMap或fromByteBuffer都会返回一个新对象),这会否定使用像这样的静态工厂方法的一些好处.关于这段代码的一些事情让我觉得错误,所以我很想听听社区关于这是否是构建新对象的有效方法的想法,或者如果不是更好的解决方案.

我已经准备好将我的第一个包上传到Hackage了!

我有这个hstest.cabal:

Executable hstest
        Main-Is:        hstest.hs
        Build-Depends:  base, mtl, directory, ghc, ghc-paths, random, QuickCheck

我知道简单地列出我的包依赖的包是不好的形式; 相反,我应该说明需要这些软件包的哪些版本.

我安装的版本是

• base = 4.1.0.0
• mtl = 1.1.0.2
• directory = 1.0.0.3
• ghc = 6.10.3
• ghc-paths = 0.1.0.5
• random = 1.0.0.1
• QuickCheck = 1.2.0.0

有没有一种简单的方法可以找出我的包实际需要的每个包的最早可接受的版本？(即没有安装大量过时的版本并逐个测试它们？)

我可以认为这些软件包的未来版本可以依赖于哪些软件包？

如何删除字符串的每个第n个元素？

我猜你会drop以某种方式使用这个功能.

像这样丢弃第一个n,你怎么能改变这个,所以只丢下第n个,然后是第n个,等等,而不是全部？

dropthem n xs = drop n xs

我有一些代码具有与此相同的结构:

import Debug.Trace

newtype SomeExpensiveHiddenType = SCHT Double

expensive :: Double -> Double -> SomeExpensiveHiddenType
expensive a b = SCHT $ trace "call expensive" (*) a b

cheap :: SomeExpensiveHiddenType -> Double -> Double
cheap (SCHT x) c = trace "call cheap" (+) x c

f1 :: Double -> Double -> Double -> Double
f1 a b c = let x = expensive a b in cheap x c

ie f1是一个函数,它根据前两个参数计算昂贵的结果,然后将其与第三个参数一起使用.我原本希望对前两个参数进行部分应用,然后重复应用第三个参数会导致昂贵的计算只运行一次.不幸的是,这种情况并非如此:

test1 = do
    putStrLn "test 1"
    let p …

我有一个像变量

a = 3

对于a的某些值,我有我想调用的相同函数:

case a of
     3 -> print "hello"
     4 -> print "hello"
     5 -> print "hello"
     6 -> print "hello something else"

因此,对于a = 3,a = 4和a = 5,我进行相同的函数调用.我能把这些组合得更好吗？我有点想找到一个解决方案:

case a of
     3 || 4 || 5 -> print "hello"
     6           -> print "hello something else"

这当然不起作用,但希望你得到我想要的结果.

谢谢.

我在haskell中有以下zip函数的实现

myzip (a:b) (z:g)
    | b == [] = []
    | g == [] = []
    | otherwise = (a,z) : myzip b g

当我将其加载到ghci时,我收到以下错误

No instance for (Eq b)
  arising from a use of `=='
In the expression: g == []
In a stmt of a pattern guard for
               an equation for `myzip':
  g == []
In an equation for `myzip':
    myzip (a : b) (z : g)
      | b == [] = []
      | g == [] = …

我正处于旅行者的关键时刻我正试图处理与游戏状态无关的玩家更新.作为参考,该项目在这里(devel分支是这个问题的相关分支).

Libraries/Universe/GameState.hs有一个功能,updateGS处理游戏状态的所有玩家更新.现在EventNetwork看起来像这样.

makeNetworkDescription :: AddHandler PlayerCommand ->
                          AddHandler () ->
                          TChan GameState ->
                          IO EventNetwork
makeNetworkDescription addCommandEvent tickHandler gsChannel = compile $ do
    eInput <- fromAddHandler addCommandEvent
    eTick <- fromAddHandler tickHandler
    let bGameState = accumB initialGS $ updateGS <$> eInput
    eGameState <- changes bGameState
    reactimate $ (\n -> (atomically $ writeTChan gsChannel n)) <$> eGameState

实现这个计时器的问题在于我所看到的所有例子都有一个与我的物理模拟不同的用例.这场比赛没有物理参与.我正在尝试使用计时器来评估独立于玩家行为的游戏状态.目前,我唯一想管理的是超空间旅行.当完全实现,从一个行星移动到另一个将改变一个Agent的location到Right Hyperspace.现在需要做的是,当一个tick发生时,distanceTraversed增加一个.然后,如果distanceTraversedequals totalDistance Agent的位置变为Left …

GHC有什么工具,比如distcc吗？或者其他更原始的技巧来进行分布式编译？

我发现GHC对版本非常敏感.这是不切实际的,因为GHC还不支持交叉编译吗？