小编Sve*_*mir的帖子

在Python中,您有两种不止一次重复某些操作的好方法.其中一个是while循环,另一个是for循环.那么让我们来看看两个简单的代码:

for i in range(n):
    do_sth()

和另外一个:

i = 0
while i < n:
    do_sth()
    i += 1

我的问题是哪一个更好.当然,第一个在文档示例中非常常见,在Internet上可以找到各种代码,它更优雅,更短,但另一方面它创建了一个完全无用的整数列表,只是为了循环他们.这不是浪费内存,特别是涉及大量的迭代吗？

那么您怎么看？哪种方式更好？

我想sshfs在我的Debian机器上安装一个远程目录,比如说/work.所以我将我的用户添加到fuse组中并运行:

sshfs user@remote.machine.net:/remote/dir /work

一切正常.但是,在启动时安装目录会非常好.所以我尝试了/etc/fstab下面给出的条目:

sshfs#user@remote.machine.net:/remote/dir /work     fuse      user,_netdev,reconnect,uid=1000,gid=1000,idmap=user  0   0

sshfs请求密码和几乎正确的安装.几乎因为我的常规user无法访问已安装的目录,当我运行时ls -la /,我得到:

d?????????   ? ?        ?               ?            ? work

如何通过fstab获得正确的权限？

我需要在Linux终端上打印一些unicode字符iostream.虽然发生了奇怪的事情.我写的时候:

cout << "\u2780";

我明白了:?这几乎就是我想要的.但是,如果我写:

cout << '\u2780';

我明白了:14851712.

问题是,我不知道在编译时要打印的确切字符.因此,我想做一些事情:

int x;
// some calculations...
cout << (char)('\u2780' + x);

哪个印刷品:?.使用wcout或wchar_t替代也不起作用.如何获得正确的打印？

从我在互联网上发现的内容来看,我直接从Debian Wheezy存储库使用g ++ 4.7.2编译器似乎很重要.

我把它配置正确,但后来我决定重新安装我的Debian(顺便提一下从wheezy切换到jessie版本).这是问题所在:

我有一个python mod_wsgi应用程序:/mnt/doc/Python/www/index.py.

$ ls -l / | grep mnt
drwxr-xr-x   3 root root  4096 sty 12 09:36 mnt

$ ls -l /mnt
drwxrwxrwx 1 sven sven 20480 sty  7 19:34 doc

$ ls -l /mnt/doc/Python/www/
total 12
drwxrwxrwx 1 sven sven 4096 Jan  3 19:52 core
-rwxrwxrwx 1 sven sven    0 Dec 22 13:25 __init__.py
drwxrwxrwx 1 sven sven    0 Dec 24 00:11 silva
-rwxrwxrwx 1 sven sven  984 Dec 22 13:47 silva.py
-rwxrwxrwx 1 sven sven …

在我看来,Haskell中的异常只能在它们被抛出后立即捕获,并且不会像在Java或Python中那样传播.一个简短的例子说明如下:

{-# LANGUAGE DeriveDataTypeable #-}

import System.IO
import Control.Monad
import Control.Exception
import Data.Typeable

data MyException = NoParseException String deriving (Show, Typeable)
instance Exception MyException

-- Prompt consists of two functions:
-- The first converts an output paramter to String being printed to the screen.
-- The second parses user's input.
data Prompt o i = Prompt (o -> String) (String -> i)

-- runPrompt accepts a Prompt and an output parameter. It converts the latter
-- to an output string …

可以在运行时从给定模板定义Haskell类型吗？这就是我的意思.假设我需要一个限制在某个范围内的整数类型(在编译时精确地未知).我还想要一个功能:

succ 0 = 1
succ 1 = 2
...
succ n = 0

n在编译时不知道.我可以这样做:

data WrapInt = WrapInt {
        value       :: Int,
        boundary    :: Int
}

wrapInt :: Int -> Int -> WrapInt
wrapInt boundary value = WrapInt value boundary

现在我想要的是保留wrapInt函数,但避免将边界存储为WrapInt类型中的值.相反,我希望它以某种方式存储在类型定义中,这当然意味着必须在运行时动态定义类型.

是否有可能在Haskell中实现这一目标？

我有以下代码:

import Control.Monad (unless)
import System.IO (isEOF, hFlush, stdout)

main :: IO ()
main = unlessFinished $ do
        putStr "$ "
        hFlush stdout
        getLine >>= putStrLn
        main
    where
    unlessFinished action = isEOF >>= flip unless action

当我编译并运行这段代码时,它会在空白行的开头显示一个光标,并且只有在我按下[Enter]后输出它$和我写的任何内容.

即使monad保证它的动作按照它们在代码中排序的顺序被调用(或者我理解这里写的是什么),它似乎也会getLine被调用.那为什么它不能正常工作？putStr "$ "IO

我想验证假设当然也是的Ring实例。在 Abelian Group 之前这很容易，但在实例中发生了一些奇怪的事情：Data.Complex.Complex ttRingRing

VerifiedRing t => VerifiedRing (Complex t) where
    ringOpIsAssociative (l :+ li) (c :+ ci) (r :+ ri) =
        ?VerifiedRing_rhs_1

现在 Idris 自己进行了一些扩展，并且该洞得到以下类型：

(l <.> (c <.> r <+> inverse (ci <.> ri)) <+> inverse (li <.> (c <.> ri <+> ci <.> r))) :+ (l <.> (c <.> ri <+> ci <.> r) <+> li <.> (c <.> r <+> inverse (ci <.> ri))) =
((l <.> c <+> …

我正在编写自己的TableModel实现.由于我需要一些共享某些功能的各种实现,我决定首先准备一个抽象类.表的字段表示为:

protected Object[][] lines;

基本上,同一列中的所有元素应该是相同的类型,但是列类可能因不同的实现而异.我想setValueAt在抽象类中编写一个通用函数,检查是否val属于正确类型.

@Override
public void setValueAt(Object val, int row, int col) {
    if (val instanceof this.getColumnClass(col))
        lines[col][row] = val;
}

编译器在此发出错误信号:

Syntax error on token "instanceof", == expected

为什么？

我想要实现的是,以下class(SampleSpace)的任何实例都应该自动成为的实例Show,因为它SampleSpace包含创建String表示所必需的整个接口,因此该类的所有可能实例实际上都是相同的.

{-# LANGUAGE FlexibleInstances #-}
import Data.Ratio (Rational)                                               

class SampleSpace space where                                               
    events          :: Ord a => space a -> [a]                              
    member          :: Ord a => a -> space a -> Bool                        
    probability     :: Ord a => a -> space a -> Rational                    

instance (Ord a, Show a, SampleSpace s) => Show (s a) where                 
    show s = showLines $ events s                                           
        where                                                               
        showLines [] = ""                                                   
        showLines (e:es) = show e ++ ": …

假设我有一个类，它为其成员类型的值声明了一些构造函数：

class C t where\n  fromInt :: Int -> t\n  fromString :: String -> t\n

进一步假设，我想使用这些多态构造函数创建一堆值并将它们放入Mapfromcontainers包中。但重要的是，我希望这些值保持多态性，并推迟对其具体类型的决定，直到从地图中提取它们为止。

newtype WrapC = WrapC (forall t . C t => t)\n\nnewtype MapC = MapC (Map String WrapC)\n

使用RankNTypes扩展，我可以定义这样一个映射，以下定义见证了确实可以从中提取多态值的事实：

get :: C t => String -> MapC -> Maybe t\nget key (MapC m) = fmap (\\(WrapC t) -> t) $ Map.lookup key m\n

然而，当我想向映射添加一个值时，我遇到了类型错误，因为 Haskell 显然无法统一一些隐藏的类型变量。定义：

add :: C t => String …

也许这是一个有点愚蠢的问题,但我已经习惯了脚本语言,问题永远不会发生,因为根本就没有编译.问题是:真正导入到Haskell可执行文件的是什么:是整合了整个导入的库还是只在可执行文件中包含了运行程序真正需要的代码？

假设我有类似的东西:

import qualified Data.Set as Set

mySet = Set.fromList [1..5]

main = print $ Set.filter (\x -> x `mod` 2 == 0) mySet

整个Data.Set模块是否包含在可执行文件中？或者它只包括Set定义fromList和filter功能？如果我写的话会有什么不同:

import qualified Data.Set as Set (Set, fromList, filter)

至少可执行的大小似乎不会受到更改的影响......

在Haskell中做一些TTD时,我最近开发了以下功能:

import Test.HUnit
import Data.Typeable
import Control.Exception

assertException :: (Show a) => TypeRep -> IO a -> Assertion
assertException errType fun = catch (fun >> assertFailure msg) handle
    where
    msg = show errType ++ " exception was not raised!"
    handle (SomeException e) [...]

该函数采用Type表示预期异常和IO操作.问题是,大部分时间我都没有抛出异常,即使我本来应该抛弃,因为懒惰.通常,失败的部分fun实际上从未在此进行过评估.

为了解决这个问题,我试图(fun >> assertFailure msg)用(seq fun $ assertFailure msg).我还尝试启用BangPatterns扩展并在fun绑定之前发出爆炸声,但没有一个帮助.那么我怎么能真正强迫Haskell fun严格评估呢？