Questions tagged «haskell»

我正在编写一个包含某些部分的图形包，并且有一些运算符和数据类型分散在整个进程中。但是我不希望用户每次都添加相应的模块，因为这很混乱，例如，我将在这样的不同路径中有一个Point类，一个Monoid角色和一个Style类 unit module Package::Data::Monoid; # $?FILE = lib/Package/Data/Monoid.pm6 role Monoid {...} unit module Package::Data::Point; # $?FILE = lib/Package/Data/Point.pm6 class Point {...} unit module Package::Data::Style; # $?FILE = lib/Package/Data/Style.pm6 class Style {...} 我希望有一个haskell类似的前奏，lib/Package/Prelude.pm6 可以写出这样的脚本 use Package::Prelude; # I can use Point right away, Style etc... 而不是做 use Package::Data::Style; use Package::Data::Point; use …

11 haskell  raku 

我有一个类型，Id a并且我正尝试防止意外强制，例如将an Id Double更改为an Id Int。 如果我正确理解类型角色，则不应编译以下内容。 {-# LANGUAGE RoleAnnotations #-} import Data.Coerce (coerce) type role Id nominal newtype Id a = Id String badKey :: Id Int badKey = coerce (Id "I point to a Double" :: Id Double) 不幸的是，它确实： Prelude> :load Id.hs [1 of 1] Compiling Main ( …

11 haskell  roles  coerce 

我正在尝试创建一个F＃函数，该函数将返回int任意嵌套的s 列表的总和。就是 但是对于工作list<int>，一list<list<int>>和a list<list<list<list<list<list<int>>>>>>。 在Haskell中，我将编写如下内容： class HasSum a where getSum :: a -> Integer instance HasSum Integer where getSum = id instance HasSum a => HasSum [a] where getSum = sum . map getSum 这会让我做： list :: a -> [a] list = replicate 6 nestedList :: [[[[[[[[[[Integer]]]]]]]]]] nestedList = list …

10 haskell  f# 

我试图了解Haskell中的存在类型，并遇到了PDF http://www.ii.uni.wroc.pl/~dabi/courses/ZPF15/rlasocha/prezentacja.pdf 请更正我到目前为止的以下理解。 现有类型似乎对它们包含的类型不感兴趣，但是与它们匹配的模式表示存在某种类型，除非＆使用Typeable或Data，否则在＆之前我们不知道它是什么类型。 当我们要隐藏类型时（例如，对于异构列表），或者在编译时我们真的不知道什么类型时，我们会使用它们。 GADT通过提供隐式forall的，为使用现有类型的代码提供清晰，更好的语法 我的怀疑 在以上PDF的第20页中，对于以下代码，提到函数不可能要求特定的缓冲区。为什么会这样呢？当我起草函数时，即使我可能不知道要放入什么数据，我也完全知道我将使用哪种缓冲区。什么是错在有:: Worker MemoryBuffer Int如果他们真的想在抽象缓冲区他们能有一个求和型data Buffer = MemoryBuffer | NetBuffer | RandomBuffer和有型状:: Worker Buffer Int data Worker x = forall b. Buffer b => Worker {buffer :: b, input :: x} data MemoryBuffer = MemoryBuffer memoryWorker = Worker MemoryBuffer (1 :: Int) memoryWorker :: …

10 haskell  gadt  existential-type 

有了量化的约束，我可以得出Eq (A f)结论吗？但是，当我尝试导出Ord（A f）时会失败。当约束类具有超类时，我不理解如何使用量化约束。我如何派生Ord (A f)以及其他具有超类的类？ > newtype A f = A (f Int) > deriving instance (forall a. Eq a => Eq (f a)) => Eq (A f) > deriving instance (forall a. Ord a => Ord (f a)) => Ord (A f) <interactive>:3:1: error: • Could not deduce …

10 haskell  typeclass  derived-class  quantified-constraints 

我看到一个非常奇怪的行为，其中Haskell的bracket功能表现不同，这取决于是否stack run或stack test使用。 考虑以下代码，其中使用两个嵌套括号来创建和清理Docker容器： module Main where import Control.Concurrent import Control.Exception import System.Process main :: IO () main = do bracket (callProcess "docker" ["run", "-d", "--name", "container1", "registry:2"]) (\() -> do putStrLn "Outer release" callProcess "docker" ["rm", "-f", "container1"] putStrLn "Done with outer release" ) (\() -> do bracket (callProcess …

10 haskell  haskell-stack 

最近，我遇到了需要将谓词函数传递给另一个函数的情况，并且我经常寻找的逻辑本质上是“此值是否与该模式匹配？” 在声明，do块和列表理解中，模式匹配似乎是首选，但是有许多函数采用谓词a -> Bool，在某种情况下以某种方式传递模式非常方便。例如，takeWhile，until，find，span，等。 到目前为止，我一直在做\a -> case a of MyCons _ -> True; otherwise -> False，或者写一个la命名函数，let myPred (MyCons _) = True; myPred _ = False in但是它们看起来都非常丑陋，而且不是很惯用。“显而易见的”（错误的）方式将是类似的，\(MyCons _) -> True但是由于自然而然地局部化而引发了错误，甚至感觉到必须有一种更清洁的方式。 有没有更简洁/干净的方式来执行这种事情？还是我做事完全是错误的方式？

10 haskell 

关于串联的一个很好的真实事实是，如果我知道方程式中的任何两个变量： a ++ b = c 那我知道第三个。 我想在我自己的concat中抓住这个想法，所以我使用了功能依赖。 {-# Language DataKinds, GADTs, FlexibleContexts, FlexibleInstances, FunctionalDependencies, KindSignatures, PolyKinds, TypeOperators, UndecidableInstances #-} import Data.Kind (Type) class Concatable (m :: k -> Type) (as :: k) (bs :: k) (cs :: k) | as bs -> cs , as cs -> bs , …

10 haskell  typeclass  functional-dependencies  type-level-computation 

最近，我开始学习Haskell，因为我想扩大我对函数式编程的了解，我必须说到目前为止我真的很喜欢它。我当前使用的资源是Pluralsight上的“ Haskell基础知识第1部分”课程。不幸的是，我在理解讲师关于以下代码的一句话时遇到了一些困难，希望你们能对此话题有所了解。 随附代码 helloWorld :: IO () helloWorld = putStrLn "Hello World" main :: IO () main = do helloWorld helloWorld helloWorld 报价单 如果您在一个do块中多次执行相同的IO操作，则它将多次运行。因此，该程序将字符串“ Hello World”输出三遍。本示例有助于说明这putStrLn不是具有副作用的功能。我们只调用putStrLn一次函数来定义helloWorld变量。如果putStrLn有打印字符串的副作用，它将只打印一次，并且helloWorld在主do-block中重复的变量将没有任何效果。 在大多数其他编程语言中，这样的程序只会打印一次“ Hello World”，因为在putStrLn调用函数时会进行打印。这种微妙的区别通常会使初学者不胜其烦，因此请仔细考虑一下，并确保您了解为什么该程序会打印“ Hello World”三遍，以及如果该putStrLn函数作为副作用打印时只打印一次。 我不明白的 对我来说，字符串“ Hello World”被打印三遍似乎是很自然的。我认为helloWorld变量（或函数？）是一种稍后调用的回调。我不明白的是，如果putStrLn产生副作用，它将导致字符串仅打印一次。或者为什么只用其他编程语言只打印一次。 假设在C＃代码中，我想它看起来像这样： C＃ （提琴） using System; public class Program { public static void HelloWorld() { Console.WriteLine("Hello …

10 haskell 

下面提供了3个函数，这些函数可以找到列表中的最后一个但第二个元素。一个使用last . init似乎比其他人快得多。我似乎不知道为什么。 为了进行测试，我使用了输入列表[1..100000000]（一亿）。最后一个几乎立即运行，而其他则需要几秒钟。 -- slow myButLast :: [a] -> a myButLast [x, y] = x myButLast (x : xs) = myButLast xs myButLast _ = error "List too short" -- decent myButLast' :: [a] -> a myButLast' = (!! 1) . reverse -- fast myButLast'' :: [a] -> a …

10 haskell 

我目前正在处理这样的功能： foo = (\(a:b:c:d:e:f:_) -> foobar a b c d e f) . (++ repeat def) 换句话说，给定一个列表，它将使用前六个元素来表示某项内容；如果列表的长度少于六个元素，则将其def用作所缺少列表的替身。这是总数，但其中的各个部分却并非如此（就像map fromJust . filter isJust），所以我不喜欢它。我试图重写它，以便它不需要使用任何局部性，并得到了： foo [] = foobar def def def def def def foo [a] = foobar a def def def def def foo [a,b] = foobar a b def def def …

10 haskell  pattern-matching 

type BSTree a = BinaryTree a data BinaryTree a = Null | Node (BinaryTree a) a (BinaryTree a) deriving Show flattenTree :: BinaryTree a -> [a] flattenTree tree = case tree of Null -> [] Node left val right -> (flattenTree left) ++ [val] ++ (flattenTree right) isBSTree :: (Ord …

10 haskell  tree  binary-tree  binary-search-tree  predicate 

我有使用镜头和GHC.Records的此代码（很奇怪）： {-# LANGUAGE DataKinds, PolyKinds, FlexibleInstances, UndecidableInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} module Main where import Control.Lens import GHC.Records data Glass r = Glass -- just a dumb proxy class Glassy r where the :: Glass r instance …

9 haskell  typeclass  typechecking 

问题 在Haskell中考虑以下设计问题。我有一个简单的符号EDSL，我想在其中表达变量和一般表达式（多元多项式），例如x^2 * y + 2*z + 1。另外，我想在表达式（例如x^2 + 1 = 1）和定义（例如）上表达某些符号方程式x := 2*y - 2。 目标是： 变量和通用表达式具有单独的类型-某些函数可能会应用于变量，而不是复杂的表达式。例如，定义运算符:=可能是类型， (:=) :: Variable -> Expression -> Definition并且不应该将复杂的表达式作为其左侧参数传递（尽管应该可以将变量作为其右侧参数传递，而无需显式转换） 。 将表达式作为的实例Num，这样就可以将整数文字提升为表达式，并为常见的代数运算（如加法或乘法）使用方便的表示法，而无需引入一些辅助包装运算符。 换句话说，我希望对表达式进行变量的隐式和静态类型转换（强制转换）。现在，我知道这样，Haskell中没有隐式类型强制转换。但是，某些面向对象的编程概念（在这种情况下为简单继承）可以在Haskell的类型系统中表达，无论有没有语言扩展。如何在保持轻量级语法的同时满足以上两个条件？可能吗 讨论区 显然，这里的主要问题是Num类型限制，例如 (+) :: Num a => a -> a -> a 原则上，可以为变量和表达式编写单个（通用）代数数据类型。然后，可以这样写:=：区分左侧表达式，只接受变量构造函数，否则会出现运行时错误。但是，这不是一个干净的静态（即编译时）解决方案... 例 理想情况下，我想实现一种轻量级语法，例如 computation = do x <- variable t …

9 haskell  casting  type-conversion  ghc  typeclass 

该Applicative类型类代表松懈monoidal函子是保留对输入功能类别的笛卡尔monoidal结构。 换句话说，给定的规范同构见证(,)形成一个单面结构： -- Implementations left to the motivated reader assoc_fwd :: ((a, b), c) -> (a, (b, c)) assoc_bwd :: (a, (b, c)) -> ((a, b), c) lunit_fwd :: ((), a) -> a lunit_bwd :: a -> ((), a) runit_fwd :: (a, ()) -> a runit_bwd :: a -> (a, …

9 haskell  functor  applicative  category-theory