标签: functional-dependencies

我在很多家庭项目中逐渐转向F#,但我对于如何将完整的应用程序连接在一起更加困难,尤其是跨领域的问题.

在C#中,如果我想记录内容,我会使用依赖注入将ILogger传递到每个类中,然后可以从代码中轻松地调用它.我可以在我的测试中验证给定特定情况的日志是通过传入模拟并验证它来编写的.

public class MyClass
{
    readonly ILogger _logger;
    public MyClass(ILogger logger)
    {
        _logger = logger;
    }

    public int Divide(int x, int y)
    {
        if(y == 0)
        {
            _logger.Warn("y was 0");
            return 0;
        }
        return x / y;
    }
}

在F#我使用的模块更多,所以上面会变成

module Stuff

let divde x y =
    match y with 
    | 0 -> 0
    | _ -> x / y

现在,如果我有一个名为Logging的模块,我可以打开它并在y为0的情况下使用日志函数,但是如何将其注入单元测试？

我可以让每个函数都使用一个日志函数(字符串 - >单位),然后使用部分应用程序连接它们,但这似乎是一项非常多的工作,就像创建一个新的函数来包装日志调用中的实际调用一样.是否有特定的模式或一点F#我缺少可以做到的？(我已经看过kprintf函数,但我仍然不知道你如何为各种测试场景指定函数,同时使用完整应用程序的具体实现)

同样,您如何存根获取数据的存储库？你需要实例化一些类并在其上设置CRUD函数,还是有一种方法可以注入你打开的模块(除了#define)

Wen使用函数依赖,我经常达到Coverage条件.可以用它抬起UndecidableInstances,但我通常会试图远离那个延伸.

这是一个有点人为的例子,没有UndecidableInstances:

{-# Language MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances #-}

data Result = Result String
  deriving (Eq, Show)

data Arguments a b = Arguments a b

class Applyable a b | a -> b where
  apply :: a -> b -> Result

instance Applyable (Arguments a b) (a -> b -> Result) where
  (Arguments a b) `apply` f = f a b

当我使结果类型更通用时,Coverage条件失败(因此需要UndecidableInstances):

{-# Language MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, UndecidableInstances #-}

data Result a = …

如您所知,有三个阿姆斯特朗的公理用于推断关系数据库的所有功能依赖性.(X,Y和Z是属性集)

1. 反身性:如果X⊆Y,则Y→X
2. 增强:如果X→Y,则任何Z的XZ→YZ
3. 传递性:如果X→Y和Y→Z,则X→Z

我理解增强和传递性,例如,如果我们有这样的模式:

SOME_SCHEMA(a,b,c,d)

具有这样的功能依赖:

1. a→b
2. b→c

通过使用增强,我们可以得到AC→BC或通过传递,我们可以得到A→C等等,但是我不知道如何使用反身公理推断出更多的功能依赖呢？一些属性是否是某个其他属性的子集,这究竟意味着什么？

你能告诉我一个使用我的架构或创建自己的架构的例子吗？

我正在寻找一种易于理解的算法来计算(手动)一组函数依赖项的闭包.一些消息来源,包括我的导师说,我应该只使用阿姆斯特朗的公理,看看我能得到什么.对我来说,这不是一个系统的方式(即容易错过的东西).

我们的课程教材(数据库系统 - 完整的书,第2版)也没有为此提供算法.

请帮我在下表中找出非平凡的功能依赖？

A.            B.              C
1             1               1
1             1               0
2             3               2
2             3               2

并解释其背后的基本概念.谢谢,,

我正在尝试做类似于高级重叠技巧的事情来定义具有重叠行为的实例.我正在尝试为元组派生一个实例,fst如果存在,将使用该snd字段的实例,否则使用该字段的实例(如果存在).这最终导致关于重叠实例的看似错误的错误.

首先,我正在使用所有的厨房水槽,除了OverlappingInstances.

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ScopedTypeVariables #-}

我也使用poly-kinded Proxy和type level或者:||:.

import Data.Proxy

type family (:||:) (a :: Bool) (b :: Bool) :: Bool
type instance (:||:) False a = a
type instance (:||:) True a = True

A是一个非常简单的课程.ThingA有一个A …

如果我正在测试的方法或过程依赖于来自第三方的一段代码,我该如何创建单元测试？说,我有一个方法,它使用来自第三方源的类,这些类需要只能在功能测试中完成的设置.我该怎么做呢？大多数情况下,第三方依赖不能被嘲笑,但我的方法确实需要使用它.

另外,我应该通过利用实际数据避免单元测试甚至功能测试吗？比如,我的测试是否永远不会连接到数据库API以临时添加数据,对其进行操作和测试,然后将其删除？

我已经打得四处TypeFamilies,FunctionalDependencies和MultiParamTypeClasses.在我看来好像TypeFamilies没有添加任何具体的功能而不是其他两个.(但反之亦然).但我知道类型家庭非常受欢迎所以我觉得我错过了一些东西:

类型之间的"开放"关系,例如转换函数,这似乎是不可能的TypeFamilies.完成MultiParamTypeClasses:

class Convert a b where
    convert :: a -> b

instance Convert Foo Bar where
    convert = foo2Bar

instance Convert Foo Baz where
    convert = foo2Baz

instance Convert Bar Baz where
    convert = bar2Baz

类型之间的表观关系,例如一种类型安全的伪鸭类型机制,通常用标准类型族来完成.完成MultiParamTypeClasses并FunctionalDependencies:

class HasLength a b | a -> b where
    getLength :: a -> b

instance HasLength [a] Int where
    getLength = length

instance HasLength (Set a) Int …

我有一个像这样的类型类：

class (Coercible a b) => Foo a b | a -> b\n

我想声明以下实例Generic：

data Thing a\n  where\n  Thing :: Foo a b => b -> Thing a\n\n-- If the @b@ uniquely determined by @a@ is @Generic@, so is @Thing a@ ...\ninstance (Foo a b, Generic b) => Generic (Thing a)\n  where\n  type Rep (Thing a) = Rep b\n

不幸的是这不能编译，错误消息是：

[typecheck] [E] \xe2\x80\xa2 Type variable \xe2\x80\x98r\xe2\x80\x99 is mentioned in the RHS,\n    but not …

我试图了解Haskell的Data.Collection图书馆的设计,来自Scala识字的背景.

它使用功能依赖(具有Scala模拟),但它们的使用方式对我来说没有意义.在Unfoldable下面再现的类中,元素类型i显示为由集合类型确定c.

class Unfoldable c i | c -> i

Run Code Online (Sandbox Code Playgroud)

具有不可观察元素的集合类.这是Foldable班级的双重性.

请解释依赖关系c -> i在这里扮演的角色和设计意图,理想情况下是一个使用示例？