小编ram*_*ion的帖子

这更像是一个风格问题,而不是一个如何.

所以我有一个需要两个命令行参数的程序:一个字符串和一个整数.

我这样实现了它:

main = do
  args@(~( aString : aInteger : [] ) ) <- getArgs
  let parsed@( ~[(n,_)] ) = reads aInteger
  if length args /= 2 || L.null parsed
    then do
      name <- getProgName
      hPutStrLn stderr $ "usage: " ++ name ++ " <string> <integer>"
      exitFailure
    else do
      doStuffWith aString n

虽然这有效,但这是我第一次真正在Haskell中使用命令行参数,所以我不确定这是否是一种非常尴尬和难以理解的方式来做我想要的.

使用惰性模式匹配工作,但我可以看到它是如何被其他编码器所厌恶.并且使用read来查看我是否有一个成功的解析在写它时肯定感到尴尬.

有没有比较惯用的方法呢？

我可以使用除Java之外的其他JVM语言(例如jruby,jython,clojure)来为android编程,还是只用java？

一年前有一个类似的问题,但我不确定自那以后是否有任何变化.

我只是重新发明了一些monad,但我不确定是哪一个.它允许您对计算的步骤进行建模,因此您可以交错执行大量计算的步骤,以找出最先完成的计算.

{-# LANGUAGE ExistentialQuantification #-}
module Computation where

-- model the steps of a computation
data Computation a = forall b. Step b (b -> Computation a) | Done a

instance Monad Computation where
   (Step b g) >>= f = Step b $ (>>=f) . g
   (Done b) >>= f = Step b f
   return = Done

runComputation :: Computation a -> a
runComputation (Step b g) = runComputation (g b)
runComputation (Done a) = a

isDone :: Computation a …

Java中是否有一个通用或标准的注释用于定义尚未实现的方法？

因此,例如,如果我使用包含类似内容的库的pre-alpha版本

@NotImplementedYet
public void awesomeMethodThatTotallyDoesExactlyWhatYouNeed(){ /* TODO */ }

我试图打电话时会收到编译时警告awesomeMethodThatTotallyDoesExactlyWhatYouNeed？

我希望能够使用ruby的OptionParser来解析表单的子命令

COMMAND [GLOBAL FLAGS] [SUB-COMMAND [SUB-COMMAND FLAGS]]

喜欢:

git branch -a
gem list foo

我知道我可以切换到一个不同的选项解析器库(如Trollop),但我有兴趣从OptionParser中学习如何做到这一点,因为我想更好地学习库.

有小费吗？

所以我试图遵循Haskell项目的建议结构,并且我在组织测试时遇到了一些问题.

为简单起见,让我们从:

src/Clue/Cards.hs # defines Clue.Cards module
testsuite/tests/Clue/Cards.hs # tests Clue.Cards module

首先,我不知道testsuite/tests/Clue/Cards.hs该包含测试代码的模块名称是什么,而另一方面,我不知道如何编译我的测试代码以便我可以链接到我的源代码:

% ghc -c testsuite/tests/Clue/Cards.hs -L src
testsuite/tests/Clue/Cards.hs:5:0:
    Failed to load interface for `Clue.Cards':
      Use -v to see a list of the files searched for.

我知道TypeSynomymInstances只允许在实例头中使用完全应用的类型同义词,但是如果我可以使用paritally应用的类型同义词,它似乎也很方便.

例如:

class Example e where
  thingy :: a -> b -> e a b

-- legit, but awkward
newtype FuncWrapper e a b = FuncWrapper { ap :: a -> e a b }
instance (Example e) => Example (FuncWrapper e) where
  thingy _ = FuncWrapper . flip thingy
funcWrapperUse :: (Example e) => e Int String
funcWrapperUse = thingy 1 "two" `ap` 3 `ap` 4 `ap` 5

-- not legal, but a little easier to use …

基本上,我想做的是:

 // in foo.scala
 val string = "this is a string\nover two lines"
 println(string)
 println(foo(string))

做这个:

% scala foo.scala
this is a string
over two lines
"this is a string\nover two lines"

基本上寻找红宝石String#inspect或哈斯克尔的模拟show :: String -> String.

我想在javascript中比较两个数组.

我想要的是:

a <b⇔∃i≥0st a [i] <b [i]且∀0≤j<i,a [j] = b [j]

因此,非负数的数组可以按需运行:

firebug> [0,1,2,3,4] < [1,0,0]
true

将负数与零进行比较按预期工作:

firebug> [-1, 1] < [0, 0]
true

但将负数与负数进行比较则令人惊讶:

firebug> [-2] < [-1]
false
firebug> -2 < -1
true

这里发生了什么,所以我可以纠正我对javascript中数组比较意味着什么的直觉？

所以,我有一对我将一起使用的类型类,我想避免每次都指定.基本上,而不是放

:: (Ord a, Fractional a, Ord b, Fractional b, ... Ord z, Fractional z) =>

在我所有类型规范的开头,我宁愿放

:: (OrdFractional a, OrdFractional b, ... OrdFractional z)

所以,我最初的想法是如何声明一个新的类型类

module Example where

class (Fractional a, Ord a) => OrdFractional a

example :: (OrdFractional a, OrdFractional b) => (a,b) -> (a,b) -> (a,b) -> Bool
example (x1,y1) (x2,y2) (x3,y3) = (x1/x2 < x2/x3) && (y1/y2 < y2/y3)

但这并不像我希望的那样自动运行:

% ghci
Prelude> :l Example.hs
Ok, modules loaded: Example.
Prelude Example> example (1::Float,3::Float) (2,2) (3,1)

<interactive>:1:0: …