小编Lui*_*las的帖子

该absurd函数Data.Void具有以下签名,其中,Void是在逻辑上无人居住类型由包导出的:

-- | Since 'Void' values logically don't exist, this witnesses the logical
-- reasoning tool of \"ex falso quodlibet\".
absurd :: Void -> a

我知道足够的逻辑来获得文档的评论,这与命题与类型的对应关系对应于有效的公式? ? a.

令我困惑和好奇的是:这个函数在什么样的实际编程问题上有用？我想也许在某些情况下它可能是一种类型安全的方式来彻底处理"不可能发生"的情况,但我对Curry-Howard的实际用法不太了解,以确定这个想法是否在正确的轨道.

编辑:最好在Haskell中的例子,但如果有人想使用依赖类型的语言我不会抱怨...

我遇到一个问题,IntelliJ 13.1.4在运行单元测试时无法ServiceLoader在src/test/resources我的模块目录中找到文件.

请在回答之前注意我已完成以下所有操作:

1. 该模块是Gradle项目,如果我运行gradle test单元测试运行正常.
2. 我过去在IntelliJ中成功运行了这个单元测试,它找到了模块.(也许是IntelliJ的早期版本？)
3. 我已经仔细检查了IntelliJ模块设置,并且该src/test/resources目录被标记为测试资源目录.(见下面的截图.)
4. 我在类中转储了单元测试类的类加载器的类路径; 它有build/classes/test/和build/classes/java目录,但也build/resources/test/没有build/resources/main/.
5. 我点击了按钮刷新所有Gradle项目.

关于还有什么可能导致IntelliJ在这里失败的任何想法？

我的模块配置的屏幕截图,显示"测试资源文件夹"设置.

因此,在我不断尝试通过小型Haskell练习半理解Curry-Howard时,我已经陷入了困境:

{-# LANGUAGE GADTs #-}

import Data.Void

type Not a = a -> Void

-- | The type of type equality proofs, which can only be instantiated if a = b.
data Equal a b where
    Refl :: Equal a a

-- | Derive a contradiction from a putative proof of @Equal Int Char@.
intIsNotChar :: Not (Equal Int Char)
intIsNotChar intIsChar = ???

很明显,这种类型Equal Int Char没有(非底层)居民,因此在语义上应该有一个absurdEquality :: Equal Int Char -> a功能......但对于我的生活,我无法想出任何方式来编写除了使用之外的其他方法undefined.

所以要么: …

我正在玩写一个网络应用程序.在这种情况下,我使用的是scotty和redis,但是这个问题出现在任何web/db组合中.在此之前我使用过happstack,所以我也喜欢那里的一个例子.

Scotty让您在嵌套的monad中定义路由,这样可以轻松访问路径中的数据库连接:

main = do
    db <- connect defaultConnectInfo
    scotty 3000 $ do

    get "/keys" $ do
        keys <- liftIO $ runRedis db $ keys "*"
        html $ T.pack $ show keys

get中的do块有类型:Web.Scotty.ActionM ().所有redis命令都有类型Database.Redis.Redis a.redis或scotty都没有monad变压器.

结合这些的最佳方法是什么？我是haskell的新手,但我确实设法让ReaderT在网上monad中工作.

理想情况下,我可以以某种方式创建一个新的monad堆栈,支持两个keys并html在同一个块中.

能比我更了解Java内存模型的人确认我理解以下代码是否正确同步？

class Foo {
    private final Bar bar;

    Foo() {
        this.bar = new Bar(this);
    }
}

class Bar {
    private final Foo foo;

    Bar(Foo foo) {
        this.foo = foo;
    }
}

我知道这段代码是正确的,但我没有完成整个过程- 在数学之前.我确实找到了两个非正式的引文,表明这是合法的,尽管我有点担心完全依赖它们:

最终字段的使用模型很简单:在该对象的构造函数中设置对象的最终字段; 并且在对象的构造函数完成之前,不要在另一个线程可以看到的地方写入对正在构造的对象的引用.如果遵循此原因,那么当另一个线程看到该对象时,该线程将始终看到该对象的最终字段的正确构造版本.它还将看到那些最终字段引用的任何对象或数组的版本,这些字段至少与最终字段一样是最新的.[ Java®语言规范:Java SE 7 Edition,第17.5节 ]

另一个参考:

对象的正确构造意味着什么？它只是意味着在构造过程中不允许对正在构造的对象的引用"逃逸".(有关示例,请参阅安全构造技术.)换句话说,不要在另一个线程可能看到它的任何地方放置对正在构造的对象的引用; 不要将它分配给静态字段,不要将其注册为任何其他对象的侦听器,依此类推.这些任务应在构造函数完成后完成,而不是在构造函数中完成.[ JSR 133(Java内存模型)常见问题解答,"最终字段如何在新JMM下工作？" ]

所以有一天我想出了如何编写这个函数(需要base-4.7.0.0或以后):

{-# LANGUAGE ScopedTypeVariables, TypeOperators, GADTs #-}

import Data.Typeable

-- | Test dynamically whether the argument is a 'String', and boast of our 
-- exploit if so.
mwahaha :: forall a. Typeable a => a -> a
mwahaha a = case eqT :: Maybe (a :~: String) of
              Just Refl -> "mwahaha!"
              Nothing -> a

所以我被带走了,并决定尝试使用它来编写一个测试其参数类型是否为Show实例的函数.如果我理解正确的话应该不起作用,因为TypeReps只存在于单形类型中.所以这个定义自然不能进行类型检查:

isShow :: forall a b. (Typeable a, Typeable b, Show b) => a -> Bool
isShow a = …

我有点难以理解如何证明免费monad的法律Functor和Monad法律.首先,让我提出我正在使用的定义:

data Free f a = Pure a | Free (f (Free f a))

instance Functor f => Functor (Free f) where
    fmap f (Pure a) = Pure (f a)
    fmap f (Free fa) = Free (fmap (fmap f) fa)

instance Functor f => Monad (Free f) where
    return = Pure
    Pure a >>= f = f a
    Free fa >>= f = Free (fmap (>>=f) fa)

{-

Functor laws:
(1) fmap id x == x …

我是否正确地得出结论,maxBound - minBound在Haskell中无法计算任意Enum和Bounded类型？或者我错过了一些技巧/黑客？这就是我所拥有的,显然无法运作:

difference :: (Enum a, Bounded a) => Int
difference = fromEnum maxBound - fromEnum minBound

错误:

Foo.hs:37:1:
    Ambiguous constraint `Enum a'
      At least one of the forall'd type variables mentioned by the constraint
      must be reachable from the type after the '=>'
    In the type signature for `difference': difference :: (Enum a, Bounded a) => Int

Foo.hs:37:1:
    Ambiguous constraint `Bounded a'
      At least one of the forall'd type variables mentioned by …

好的,所以我已经想出如何使用包来实现Reader(并且ReaderT未显示)operational:

{-# LANGUAGE GADTs, ScopedTypeVariables #-}

import Control.Monad.Operational

data ReaderI r a where
    Ask :: ReaderI r r

type Reader r a = Program (ReaderI r) a

ask :: Reader r r
ask = singleton Ask

runReader :: forall r a. Reader r a -> r -> a
runReader = interpretWithMonad evalI
    where evalI :: forall b. ReaderI r b -> (r -> b)
          evalI Ask = id

但我无法弄清楚如何使用免费monad(我使用Edward Kmett的free包)来解决这个问题.我得到的最接近的是这个,我明白是作弊(关于如何((->) r) …

我刚刚发现自己编写了如下代码:

import Prelude hiding (id, (.))
import Control.Category
import Control.Monad ((<=<))

-- | Intended law:
--
--     map forward . backward == id
--
data Invertible a b = 
    Invertible { forward :: a -> b
               -- Maybe switch from [a] to Monad m => m a? (Requires RankNTypes)
               , backward :: b -> [a] }

instance Category Invertible where
    id = Invertible id (:[])
    f . g = Invertible { forward  = forward f . forward g
                       , backward …