小编ais*_*ais的帖子

nameof(order.User.Age)仅返回"Age"而不是"order.User.Age"

以更有限的方式做到这一点的原因是什么？如果我们只想要姓氏,我们可以做类似的事情

public static GetLastName(this string x) { 
    return string.Split(x, '.').Last();
}
nameof(order.User.Age).GetLastName()

有了一个操作员,我们可以同时获得"Age"和"order.User.Age".但是根据目前的实施情况,我们只能获得"年龄".

这个决定背后有一些逻辑吗？

编辑:例如,这种行为是MVC绑定所必需的

Html.TextBox(nameof(order.User.Age))

data Tree t = Empty | Node t (Tree t) (Tree t)

我们可以创建Functor实例并使用

fmap :: (t -> a) -> Tree t -> Tree a

但是如果不是(t - > a)我想要(树t - > a)那么我可以访问整个(节点t)而不仅仅是t

treeMap :: (Tree t -> a) -> Tree t -> Tree a
treeMap f Empty = Empty
treeMap f n@(Node _ l r) = Node (f n) (treeMap f l) (treeMap f r)

与折叠相同

treeFold :: (Tree t -> a -> a) -> a -> Tree t -> a …

我有这个AST

data ExprF r = Const Int | Add   r r
type Expr = Fix ExprF

我想比较一下

x = Fix $ Add (Fix (Const 1)) (Fix (Const 1))
y = Fix $ Add (Fix (Const 1)) (Fix (Const 2))

但是所有递归方案函数似乎只适用于单一结构

显然我可以使用递归

eq (Fix (Const x)) (Fix (Const y)) = x == y
eq (Fix (Add x1 y1)) (Fix (Add x2 y2)) = (eq x1 x2) && (eq y1 y2)
eq _ _ = False

但我希望可以使用某种zipfold功能.

有人可以展示一个简单的例子,其中状态monad可以比直接传递状态更好吗？

bar1 (Foo x) = Foo (x + 1)

VS

bar2 :: State Foo Foo
bar2 = do
  modify (\(Foo x) -> Foo (x + 1))
  get

我读了为什么MonadPlus而不是Monad + Monoid？我理解理论上的差异,但我无法弄清楚实际的差异,因为对于List来说它看起来是一样的.

mappend [1] [2] == [1] <|> [2]

是.也许有不同的实现

mappend (Just "a") (Just "b") /= (Just "a") <|> (Just "b")

但我们可以像Alternative一样实现Maybe Monoid

instance Monoid (Maybe a) where
  Nothing `mappend` m = m
  m `mappend` _ = m

那么,有人可以展示代码示例,它解释了Alternative和Monoid之间的实际区别吗？

问题不是为什么MonadPlus而不是Monad + Monoid？

例如,我正在为列表编写一些函数,我想使用长度函数

foo :: [a] -> Bool
foo xs = length xs == 100

有人能理解这个函数是否可以与无限列表一起使用？

或者我应该总是考虑无限列表并使用这样的东西

foo :: [a] -> Bool
foo xs = length (take 101 xs) == 100

而不是直接使用长度？

如果haskell将具有FiniteList类型,那么长度和foo将是什么

length :: FiniteList a -> Int
foo :: FiniteList a -> Bool

你能展示一个简单的代码示例,它会显示Data.Functor's Product和Coproduct？的有用应用吗？

我只是想以某种方式说"我希望这个项目中的所有方法都使用[JavaScript]"手动注释每个方法都很烦人

myLiftM2 ::  Monad m => (a -> a1 -> m b) -> m a -> m a1 -> m b
myLiftM2 f x y = x >>= (\r1 -> y >>= (\r2 -> f r1 r2))

在liftM2中f返回b,但myLiftM2返回mb

例如我有这种类型

type Foo = {
    foo?: number
    bar: string
    obj?: {
        qwe?: number
        asd: string
    }
}

我想要一个类型

type Foo2 = {
    foo: number
    obj: {
        qwe: number
    }
}

我试过这个

type OptionalKeys<T> = {[P in keyof T]: T[P] extends undefined ? P : never }[keyof T]

type PickOptionalProperties<T> = {
    [P in OptionalKeys<T>]-?: PickOptionalProperties<T[P]>
};
type Foo2 = PickOptionalProperties<Foo>  
const o: Foo2 = {
}

但它不起作用，我不知道为什么