小编chi*_*ro2的帖子

我有一个包含许多字段的数据类型:

data ManyFields a b c d .. = MF { f1 :: a, f2 :: b, f3 :: c .. }

问题一

如何将功能映射到每个字段,同时避免map为每个字段实现功能.例如,这看起来非常乏味且非惯用:

-- | Note I am explicitly constructing ManyField after mapping a function onto the field
-- | This looks bad
mapf1 :: (a -> a1) -> ManyFields a b c ..  -> ManyFields a1 b c ..
mapf1 g mf = MF (g . f1 $ mf) (f2 mf) ..

-- | Repeat for …

这是我遇到问题的代码:

{-# LANGUAGE GADTs, LANGUAGE DataKinds #-} 

-- * Universe of Terms * -- 

type Id = String 

data Term a where 
   Var :: Id -> Term a
   Lam :: Id -> Type -> Term b -> Term (a :-> b)
   App :: Term (a :-> b) -> Term a -> Term b 
   Let :: Id -> Term a -> Term b -> Term b 

   Tup :: Term a -> Term b -> Term (a :*: b)   -- * existing …

假设我有一个monadT:

type Wrap a = ReaderT Env ( StateT Int ( StateT Int Identity ) ) a

这里要注意的重要一点是,一个StateT正在包装另一个,并且两者都包含在第三个MonadT内,即ReaderT.

以及相应的runWrap函数以方便:

type Env = Map.Map Char Integer

runWrap :: Env -> Int -> Int -> Wrap a -> a
runWrap env st1 st2 m = runIdentity $ evalStateT ( evalStateT ( runReaderT m env ) st2 ) st1

一个通用的tock状态monad:

tock :: (Num s, MonadState s m) => m ()
tock = do modify (+1)

我现在创建一个包裹monadT,其中我使用tock:

aWrap :: Wrap ( Int, Int ) …

具体来说,假设我有这个monadT堆栈:

type MHeap e ret = MaybeT ( StateT [e] Identity ) ret

和一个runMheap函数:

runMheap :: MHeap e ret -> [e] -> ( Maybe ret, [e] )
runMheap m es = runIdentity $ runStateT ( runMaybeT m ) es

我想创建一个MHeap查找列表的第i个元素(注意我们可能在这里有一个out of bound错误),然后如果元素存在则将其附加到列表的末尾,否则按原样保留列表.在代码中:

mheapOp' :: Int -> MHeap Int ( Maybe Int )
mheapOp' i = do 
    xs <- lift $ get
    -- I would like to use the pure function ( !! ) here
    let ma = fndAtIdx …

我有一些应用程序架构,其中用户输入流到某些自动机,它在事件流的上下文中运行,并将用户引导到应用程序的不同部分.应用程序的每个部分都可以根据用户输入执行某些操作.但是,应用程序的两个部分是共享某个状态,并且在概念上是读取和写入同一个状态.需要注意的是,两个"线程"没有同时运行,其中一个"暂停"而另一个"产生"输出.描述这种状态共享计算的规范方法是什么,而不需要求助于某些全局变量？两个"线程"是否有意义保持本地状态通过某种形式的消息传递同步,即使它们不是以任何方式并发？

没有代码示例,因为问题更具概念性,但欢迎使用Haskell(使用任何FRP框架)或其他语言的示例答案.

假设我有一些功能:

function g(a,b,c){ return a + b + c }

而且我想把它变成"咖喱"形式(在引文中,因为它本身并不完全是咖喱):

function h(a,b,c){

    switch(true){

        case (a !== undefined && b !== undefined && c !== undefined):
            return a + b + c

        case (a !== undefined && b !== undefined && c === undefined): 
            return function(c){ return a + b + c }

        case (a !== undefined && b == undefined  && c === undefined ):
            return function(b,c){
                return (c === undefined) ? function(c){ return a + b + c …

我无法解决这个问题.但是这里有一个用例:假设你有两个monad变换器,t并且s在同一个monad上进行转换m:

master :: (MonadTrans t, Monad m) => t m a b
slave  :: (MonadTrans t, Monad m) => s m a b

而且我想要构建master并且slave当m原语被提升到t和时它们可以相互通信s.签名可能是:

bound :: (MonadTrans t, MonadTrans s, Monad m, Monoid a) => t m a b -> s m a b -> (...)
But what is the type of (...) ?

一个用例,用含糖表示法:

master :: Monoid a => a -> t m …

我试图建立一个有向图，并计算该图上的个性化页面排名。因此，假设我有一个顶点{1,2,3,4}和边从 2、3和4到顶点1的图形，我想：

（1）相对于1计算每个顶点的个性化页面等级

（2）针对2计算每个顶点的个性化页面等级。

问题是我应该如何在个性化页面排名功能中传递此选项。以下代码似乎无法满足我的要求：

import networkx as nx

G = nx.DiGraph()

[G.add_node(k) for k in [1,2,3,4]]
G.add_edge(2,1)
G.add_edge(3,1)
G.add_edge(4,1)


ppr1 = nx.pagerank(G,personalization={1:1, 2:1, 3:1, 4:1})
ppr2 = nx.pagerank(G,personalization={1:2, 2:2, 3:2, 4:2})

现在ppr1 == ppr2，即使事实并非如此。

================================================== ================更新。

作为对以下评论的回应，我对个性化页面排名的理解来自以下方面：

等效定义是从s开始的随机游走的终端节点。令（X0，X1，...，XL）是从长度为L0的X0 ＝ s开始的随机游动。几何（？）。在这里由L？几何（？）是指Pr [L = ] = (1??) ？。步行从s开始，并在每个步骤中执行以下操作：以概率？，终止；剩下的概率为1？，继续到当前节点的随机邻居。如果当前节点为u，则随机邻居为v？。如果对图进行加权，则以概率wu，v选择N out（u）；如果对图进行加权，则以均匀概率1 / dout（u）进行选择。那么任何节点t的PPR就是该行进在t处停止的概率：

在本论文的第6页上找到：https : //cs.stanford.edu/people/plofgren/bidirectional_ppr_thesis.pdf

因此，我假设在计算“相对于s的t的个性化页面等级”时我正在寻找的是，如果我们根据上述过程从s开始随机游走，那么该游走终止于t的概率是多少。

我正在按照此处的文档进行操作：https://docs.alchemyapi.io/alchemy/tutorials/how-to-create-an-nft/how-to-mint-a-nft。并拥有以下形式的智能合约：

pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

  contract NFTA is ERC721, Ownable {

     using Counters for Counters.Counter;
     Counters.Counter public _tokenIds;
     mapping (uint256 => string) public _tokenURIs;
     mapping(string => uint8) public hashes;

     constructor() public ERC721("NFTA", "NFT") {}

     function mintNFT(address recipient, string memory tokenURI)
          public onlyOwner
          returns (uint256)
      {
          _tokenIds.increment();

          uint256 newItemId = _tokenIds.current();
          _mint(recipient, newItemId);
          _setTokenURI(newItemId, tokenURI);

          return newItemId;
     }

     /**
      * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
      *
      * Requirements:
      *
      * - …

我的问题的要点是我有一个确定性状态自动机,它根据一个移动列表进行转换,我希望这个转换序列充当另一个函数的"计算上下文".这个其他函数会在每次转换时观察状态机,并用它做一些计算,模糊地让人联想到模型视图模式.通常,这个其他功能可能只是读取机器所处的当前状态,并将其打印到屏幕上.

我的状态机实现:

data FA n s = FA { initSt1 :: n, endSt1 :: [n], trans1 :: n -> s -> n }

-- | Checks if sequence of transitions arrives at terminal nodes
evalFA :: Eq n => FA n s -> [s] -> Bool
evalFA fa@(FA _ sfs _ ) = (`elem` sfs) . (runFA fa)

-- | Outputs final state reached by sequence of transitons
runFA :: FA n s -> [s] -> n
runFA (FA s0 …