在阅读了几个关于Haskell状态monad的教程之后,我想自己尝试一下.我读过的教程声称Control.Monad.State提供了以下定义:
newtype State s a = State { runState :: s -> (a,s) }
但是,我似乎无法找到State数据构造函数:
Prelude> import Control.Monad.State
Prelude Control.Monad.State> :t State
<interactive>:1:1:
Not in scope: data constructor `State'
Perhaps you meant `StateT' (imported from Control.Monad.State)
我也尝试过Hoogle搜索,State但没有找到任何具有预期类型的数据构造函数.
在哪儿State构造去了？它曾经存在过吗？或者我只是在错误的地方寻找？基本上我想知道我需要做什么来创建状态monad.
我看了$!操作员强制严格评估.那么为什么这仍然有效呢？
Prelude> take 10 $! repeat 1
[1,1,1,1,1,1,1,1,1,1]
我期待ghc永远磨掉,试图评估1的无限列表.
假设我有一个抽象基类BaseTimeCollection和至少一个ConcreteTimeCollection继承自基类的具体类.
我希望我的基类继承自己ICollection<T>.
继承ICollection<T>需要我提供许多方法的实现,包括IEnumerable.GetEnumerator()和IEnumerable<T>.GetEnumerator.
我不想实现这些方法BaseTimeCollection- 相反,我更愿意在每个具体类中单独实现它们.
这是我遇到麻烦的地方.
这些GetEnumerator方法需要明确声明,因为它们中有两个具有相同的名称但返回类型不同.但是,似乎只要我使签名显式,我就不能再使用abstract修饰符了.基本上我被迫GetEnumerator在我的基类中实现该方法.
public abstract class BaseTimeCollection : ICollection<Time>
{
abstract IEnumerator IEnumerable.GetEnumerator(); // compile error: The modifier 'abstract' is not valid for this item
abstract IEnumerator<Time> IEnumerable<Time>.GetEnumerator(); // compile error: The modifier 'abstract' is not valid for this item
}
public class ConcreteTimeCollection : BaseTimeCollection
{
IEnumerator IEnumerable.GetEnumerator()
{
// this is where I would like to …我正在尝试实现一个回调，该回调将控制从中断服务例程传递到 c++ 类上的成员函数。我认为lambdas和闭包将是一种方便的方法，但我在实现它时遇到了麻烦。下面是我的代码的简化版本。
我遇到的问题是如何将“函数指针”存储到“ lambda ”。
class Gpio
{
public:
typedef void (*ExtiHandler)();
private:
ExtiHandler handler;
public:
void enable_irq(ExtiHandler handler_in)
{
// enable interrupt
// ...
// save handler so callback can be issued later
handler = handler_in;
}
};
class Button
{
private:
Gpio& pin;
public:
Button(Gpio& pin_in) : pin(pin_in)
{
};
void button_pressed()
{
// do something
}
void init()
{
pin.enable_irq([this]() { this->button_pressed(); });
}
};
编译失败并显示以下错误消息；
no matching function for call to …我正在研究c#中的应用程序.为了使这个应用程序工作,我发现自己做了一些对我选择的语言感到非常不自然的事情.在经历了许多重构和改进后,我逐渐意识到我试图实现的功能实际上是一种"懒惰评估"(我认为).这就是我想要的......
// Criteria 1: Lazy evaluation of expressions
int x = LazyEvaluated.New<int>();
int y = LazyEvaluated.New<int>();
int z = LazyEvaluated.New<int>();
z.Assign(x + y);
Assert.ThrowsException(z.Evalutate());
x.Assign(1);
Assert.ThrowsException(z.Evalutate());
y.Assign(2);
Assert.Equals(3, z.Evaluate());
x.Assign(3);
Assert.Equals(5, z.Evaluate());
// Criteria 2: Referencing relative to parent object
Car myCar = LazyEvaluated.New<Car>();
Engine engineInMyCar = LazyEvaluated.New<Engine>();
double displacementOfMyEngine = LazyEvaluated.New<double>();
engineInMyCar = myCar.Engine;
displacementOfMyEngine = engineInMyCar.Displacement;
Car subaru = new Car(new FlatFourEngine());
Car falcon = new Car(new InlineSixEngine());
myCar.Assign(subaru);
Assert.IsTypeOf<FlatFourEngine>(engineInMyCar.Evaluate());
Assert.IsEqual(2.0, displacementOfMyEngine.Evaluate());
myCar.Assign(falcon);
Assert.IsTypeOf<InlineSixEngine>(engineInMyCar.Evaluate());
Assert.IsEqual(4.0, displacementOfMyEngine.Evaluate());
这些是我用于说明的简单类定义......
public …我想了解Collection类型的以下两个定义之间的区别.
具有多参数类型类和功能依赖性(取自此处);
{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FunctionalDependencies #-}
class Eq e => Collection c e | c -> e where
insert :: c -> e -> c
member :: c -> e -> Bool
instance Eq a => Collection [a] a where
insert = flip (:)
member = flip elem
只有一个类型参数;
class Collection c where
insert :: Eq e => c e -> e -> c e
member :: Eq e => c e -> e -> Bool …为什么我的编译器不允许这样做？
class Resource
{
private:
static const int max_instances = 10;
// set aside memory to be used later with placement new
static char memory[max_instances * sizeof(Resource)]; // error: invalid application of 'sizeof' to incomplete type 'Resource'
};
我正在努力学习Haskell,所以我想我会潜入并尝试一个monad.请参阅下面的我对Calc的实现.这类似于State monad,除了state始终是用于缓存结果的Map.每个Calc都有自己的GUID(尚未实现),用作从地图中检索缓存值的键.
import qualified Data.Map as Map
import Control.Monad
import Data.Dynamic
type CalcId = Int
type Ctx = Map.Map CalcId Dynamic
data Calc a = Calc { eval :: Ctx -> (a, Ctx),
guid :: CalcId }
instance Monad Calc where
(>>=) :: Calc a -> (a -> Calc b) -> Calc b
c1 >>= f = Calc {eval=c2Eval, guid=c2Id}
where c2Id = 1 -- need a way of generating a GUID. add later.
c2Eval = \ctx ->
case (Map.lookup …