小编Sib*_*ibi的帖子

我使用jQuery动态添加新元素。但是新添加的元素没有正确应用CSS。

我已经用jsFiddle演示了我的问题。新添加的输入文本框之间有不同的间距。

HTML代码：

<fieldset>
    <div class="control-group custom">
        <label class="input-mini" for="first">Start</label>
        <label class="input-mini" for="first">End</label>
        <label class="input-mini" for="first">Share</label>
    </div>
    <div class="control-group custom">
        <input type="text" class="input-mini">
        <input type="text" class="input-mini">
        <input type="text" class="input-mini">
    </div>
    <div>   
     <a id="plus_time_button" class="btn plus" href="#">
      <i class="icon-plus-sign"></i>
     </a>
    </div>
</fieldset> 

JS代码：

 $("#plus_time_button").live("click", function () {
    var new_row = "<div class=\"control-group custom\"><input type=\"text\" class=\"input-mini\"><input type=\"text\" class=\"input-mini\"><input type=\"text\" class=\"input-mini\"></div><div><a id=\"plus_time_button\" class=\"btn plus\" href=\"#\"><i class=\"icon-plus-sign\"></i></a></div>";
    $("fieldset div:last-child").remove();
    $("fieldset").append(new_row);
});

CSS代码：

.custom label {
    padding: 4px 6px;
    margin-right: 20px;
    display: inline-block; …

假设我的记录(包含大量字段)定义如下:

data Sample_Record = Sample_Record { record_field1 :: Int,
                                     record_field2 :: Int,
                                     record_field3 :: Float
                                    }

a = Sample_Record { record_field1 = 4,
                    record_field2 = 5,
                    record_field3 = 5.4
                  }

我可以创建一个新的记录类型Sample_Record,a其中一个字段被修改？

我在 Real World Haskell 上遇到了以下句子：

懒惰的评估有一些令人毛骨悚然的效果。假设我们要查找未排序列表的 k 个最小值元素。在传统语言中，显而易见的方法是对列表进行排序并取前 k 个元素，但这很昂贵。为了提高效率，我们将编写一个特殊的函数，一次性获取这些值，并且它必须执行一些中等复杂的簿记。在 Haskell 中，先排序再取的方法实际上表现良好：懒惰确保列表只会被排序到足以找到 k 个最小元素。

他们为此提供了一个代码实现：

minima k xs = take k (sort xs)

但真的是这样吗？我认为即使在 Haskell 中，它也应该做一个完整的列表来取出k元素。（想象一下在列表末尾有最小的数字）。我在这里错过了什么吗？

让我们说,我有两个Maybe Bool值,我想实现以下功能:

• 如果两者都是Just值,我想||在它们之间执行值.
• 如果其中Nothing一个是Just值而另一个是值,那么我希望将Just值作为输出.
• 如果两者都是Nothing,那么我想Just False作为输出.

我知道这可以通过模式匹配来实现.但是可以使用任何monadic函数来实现结果吗？

liftM2 适用于这种情况:

ghci> liftM2 (||) (Just True) (Just False)
Just True

但是当一个输入中的任何一个输入时(我想要其他值)liftM2将产生.即:NothingNothingJust

ghci> liftM2 (||) (Nothing) (Just False)
Nothing

但我想Just False在上述情况下.

是否可以使用任何monadic函数执行此操作？

是否有任何Haskell停止/腌制/取消/恢复计算的方式？

关于这一点的一些相关讨论似乎在这里发生,但没有提出适当的解决方案.这个讨论还很旧.

如果存在某种类型的事件系统用于触发计算的停止和恢复状态,那也是好的.

我使用以下方法编写了以下解析代码attoparsec:

data Test = Test {
  a :: Int,
  b :: Int
  } deriving (Show)

testParser :: Parser Test
testParser = do
  a <- decimal
  tab
  b <- decimal
  return $ Test a b

tParser :: Parser [Test]
tParser =  many' $ testParser <* endOfLine

这适用于小型文件,我这样执行:

main :: IO ()
main = do
  text <- TL.readFile "./testFile"
  let (Right a) = parseOnly (manyTill anyChar endOfLine *> tParser) text
  print a  

但是当文件大小超过70MB时,它会占用大量内存.作为解决方案,我想我会用attoparsec-conduit.在完成他们的API之后,我不确定如何让它们一起工作.我的解析器有类型,Parser Test但它 …

我用自定义文件编写了一个解析器attoparsec.分析报告表明,大约67%的内存分配是在一个名为的函数中完成的tab,这也耗费了大部分时间.该tab功能是非常简单的:

tab :: Parser Char
tab = char '\t'

整个分析报告如下:

       ASnapshotParser +RTS -p -h -RTS

    total time  =       37.88 secs   (37882 ticks @ 1000 us, 1 processor)
    total alloc = 54,255,105,384 bytes  (excludes profiling overheads)

COST CENTRE    MODULE                %time %alloc

tab            Main                   83.1   67.7
main           Main                    6.4    4.2
readTextDevice Data.Text.IO.Internal   5.5   24.0
snapshotParser Main                    4.7    4.0


                                                             individual     inherited
COST CENTRE        MODULE                  no.     entries  %time %alloc   %time %alloc

MAIN               MAIN                     75           0    0.0    0.0   100.0 …

在真实世界的Haskell 章节中,他们给出了(>>)这样的理由:

当我们想要按特定顺序执行操作时,我们使用此函数,但不关心它的结果是什么.

然后他们给出了一个很好的例子来证明它:

ghci > print "foo" >> print "bar"
"foo"
"bar"

在本章的后面,他们使用相同的概念在State monad中生成随机值:

getRandom :: Random a => RandomState a
getRandom =
  get >>= \gen ->
  let (val, gen') = random gen in
  put gen' >>
  return val

但是为什么在这种情况下他们put gen' >>最终会忽略它的输出值而使用该陈述.为什么以上功能不能像这样:

getRandom :: Random a => RandomState a
getRandom =
  get >>= \gen ->
  let (val, gen') = random gen in
  return val

只是为了完成这个问题,我正在为上面的上下文添加相关的类型定义和函数:

newtype State s a = State {
  runState :: …

我已经编写了一个秒差距代码，它非常适合我想要的。它按预期解析以下文件：

4,5
6,7

对应的代码是这样的：

import Text.ParserCombinators.Parsec
import Control.Applicative hiding ((<|>))
import Control.Monad

data Test = Test Integer Integer deriving Show

integer :: Parser Integer
integer = rd <$> many1 digit
    where rd = read :: String -> Integer

testParser :: Parser Test
testParser = do
  a <- integer
  char ','
  b <- integer
  return $ Test a b

testParserFile = endBy testParser eol

eol :: Parser Char
eol = char '\n'

main = do
  a <- parseFromFile testParserFile "./jack.txt"
  print …

我的类型:

data Test = Test {
 a :: Int,
 b :: Int
} deriving (Show)

我的解析器:

testParser :: Parser Test
testParser = do
  a <- decimal
  tab
  b <- decimal
  return $ Test a b

tab = char '\t'

现在为了跳过第一行,我做了这样的事情:

import qualified System.IO as IO    

parser :: Parser Test
parser = manyTill anyChar endOfLine *> testParser

main = IO.withFile testFile IO.ReadMode $ \testHandle -> runEffect $
         for (parsed (parser <* endOfLine) (fromHandle testHandle)) (lift . print)

但是上面的parser函数会使每个备用链接跳过(很明显).如何以与Pipes生态系统一起工作的方式跳过第一行(Producer …