lens

I needed a lens function that works like over , but with monadic operations: overM :: (Monad m) => Lens s t a b -> (a -> m b) -> (s -> m t) While this function is easy to define (it's actually just an identity modulo WrappedMonad ), I wonder are such functions defined somewhere in lens ? {-# LANGUAGE RankNTypes #-} import Control.Applicative import Control.Lens overF :: (Functor f) => Lens s t a b -> (a -> f b) -> (s -> f t) overF l = l overM :: (Monad m) => Lens s t a b -> (a -> m b) -> (s -> m t) overM l = (unwrapMonad .) . l . (WrapMonad .) in Control.Lens.Traversal: traverseOf :: Over p f

Context: This question is specifically in reference to Control.Lens (version 3.9.1 at the time of this writing) I've been using the lens library and it is very nice to be able to read and write to a piece (or pieces for traversals) of a structure. I then had a though about whether a lens could be used against an external database. Of course, I would then need to execute in the IO Monad . So to generalize: Question: Given a getter, (s -> m a) and an setter (b -> s -> m t) where m is a Monad, is possible to construct Lens s t a b where the Functor of the lens is now contained to also be a Monad?

一、两数之和#解法1class Solution(object): def twoSum(self, nums, target): lens = len(nums) for i in range(0,lens): for j in range(i+1,lens): num1 = nums[i] num2 = nums[j] if (num1 + num2 == target): # m = nums.index(num1) # n = nums.index(num2) lis = [i,j] return (lis) twoSum(0,[4,3,2], 5)#解法2class Solution(object): def twoSum(self, nums, target): j = -1 lens = len(nums) for i in range(1,lens): temp = nums[:i] if (target - nums[i]) in temp: j = temp.index(target - nums[i]) break if j >= 0: lis = [j,i] return (lis) twoSum(0,[4,3,2], 5) 来源： https://www.cnblogs.com/xiaojingjingzhuanshu/p/11539879.html

Given an input string ( s ) and a pattern ( p ), implement regular expression matching with support for '.' and '*' . '.' Matches any single character. '*' Matches zero or more of the preceding element. The matching should cover the entire input string (not partial). Note: s could be empty and contains only lowercase letters a-z . p could be empty and contains only lowercase letters a-z , and characters like . or * . Example 1: Input: s = "aa" p = "a" Output: false Explanation: "a" does not match the entire string "aa". Example 2: Input: s = "aa" p = "a*" Output: true Explanation: '*' means

This question already has an answer here: How to derive instances for records with type-families 2 answers Here's what I've got, which is not compiling: {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE FunctionalDependencies #-} import Data.Text as T import Data.Int (Int64) import Control.Lens type family Incoming validationResult baseType type instance Incoming Validated baseType = baseType type instance Incoming ValidationErrors baseType = Either [T.Text]

I'm currently writing a Haskell program that involves simulating an abstract machine, which has internal state, takes input and gives output. I know how to implement this using the state monad, which results in much cleaner and more manageable code. My problem is that I don't know how to pull the same trick when I have two (or more) stateful objects interacting with one another. Below I give a highly simplified version of the problem and sketch out what I have so far. For the sake of this question, let's assume a machine's internal state consists only of a single integer register, so that its