diff --git a/Changes.md b/Changes.md new file mode 100644 --- /dev/null +++ b/Changes.md @@ -0,0 +1,2 @@ +* 0.22.0.0 + - Initial release diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,178 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + diff --git a/README.markdown b/README.markdown new file mode 100644 --- /dev/null +++ b/README.markdown @@ -0,0 +1,9 @@ +# riak-protobuf-lens + +Generated lenses for every field exported by `riak-protobuf`. + +To generate: + + $ ./generate.sh + +(this requires `stack`) diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/app/MakeLenses.hs b/app/MakeLenses.hs new file mode 100644 --- /dev/null +++ b/app/MakeLenses.hs @@ -0,0 +1,151 @@ +-- THIS FILE WAS AUTO-GENERATED BY ./generate.sh +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE FunctionalDependencies #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE TemplateHaskell #-} +module Main where +import TH +import Lens.Micro (Lens') +import Data.ByteString.Lazy (ByteString) +import Data.Sequence (Seq) +import GHC.Int (Int64) +import GHC.Word (Word32) +import qualified Network.Riak.Protocol.AuthRequest +import qualified Network.Riak.Protocol.BucketKeyPreflistItem +import qualified Network.Riak.Protocol.BucketProps +import qualified Network.Riak.Protocol.CommitHook +import qualified Network.Riak.Protocol.Content +import qualified Network.Riak.Protocol.CounterGetRequest +import qualified Network.Riak.Protocol.CounterGetResponse +import qualified Network.Riak.Protocol.CounterOp +import qualified Network.Riak.Protocol.CounterUpdateRequest +import qualified Network.Riak.Protocol.CounterUpdateResponse +import qualified Network.Riak.Protocol.CSBucketRequest +import qualified Network.Riak.Protocol.CSBucketResponse +import qualified Network.Riak.Protocol.DeleteRequest +import qualified Network.Riak.Protocol.DtFetchRequest +import qualified Network.Riak.Protocol.DtFetchResponse +import qualified Network.Riak.Protocol.DtOp +import qualified Network.Riak.Protocol.DtUpdateRequest +import qualified Network.Riak.Protocol.DtUpdateResponse +import qualified Network.Riak.Protocol.DtValue +import qualified Network.Riak.Protocol.ErrorResponse +import qualified Network.Riak.Protocol.GetBucketKeyPreflistRequest +import qualified Network.Riak.Protocol.GetBucketKeyPreflistResponse +import qualified Network.Riak.Protocol.GetBucketRequest +import qualified Network.Riak.Protocol.GetBucketResponse +import qualified Network.Riak.Protocol.GetBucketTypeRequest +import qualified Network.Riak.Protocol.GetClientIDRequest +import qualified Network.Riak.Protocol.GetClientIDResponse +import qualified Network.Riak.Protocol.GetRequest +import qualified Network.Riak.Protocol.GetResponse +import qualified Network.Riak.Protocol.GetServerInfoRequest +import qualified Network.Riak.Protocol.IndexObject +import qualified Network.Riak.Protocol.IndexRequest +import qualified Network.Riak.Protocol.IndexResponse +import qualified Network.Riak.Protocol.Link +import qualified Network.Riak.Protocol.ListBucketsRequest +import qualified Network.Riak.Protocol.ListBucketsResponse +import qualified Network.Riak.Protocol.ListKeysRequest +import qualified Network.Riak.Protocol.ListKeysResponse +import qualified Network.Riak.Protocol.MapEntry +import qualified Network.Riak.Protocol.MapField +import qualified Network.Riak.Protocol.MapField.MapFieldType +import qualified Network.Riak.Protocol.MapOp +import qualified Network.Riak.Protocol.MapReduce +import qualified Network.Riak.Protocol.MapReduceRequest +import qualified Network.Riak.Protocol.MapUpdate +import qualified Network.Riak.Protocol.MapUpdate.FlagOp +import qualified Network.Riak.Protocol.ModFun +import qualified Network.Riak.Protocol.Pair +import qualified Network.Riak.Protocol.PingRequest +import qualified Network.Riak.Protocol.PutRequest +import qualified Network.Riak.Protocol.PutResponse +import qualified Network.Riak.Protocol.ResetBucketRequest +import qualified Network.Riak.Protocol.SearchDoc +import qualified Network.Riak.Protocol.SearchQueryRequest +import qualified Network.Riak.Protocol.SearchQueryResponse +import qualified Network.Riak.Protocol.ServerInfo +import qualified Network.Riak.Protocol.SetBucketRequest +import qualified Network.Riak.Protocol.SetBucketTypeRequest +import qualified Network.Riak.Protocol.SetClientIDRequest +import qualified Network.Riak.Protocol.SetOp +import qualified Network.Riak.Protocol.YzIndex +import qualified Network.Riak.Protocol.YzIndexDeleteRequest +import qualified Network.Riak.Protocol.YzIndexGetRequest +import qualified Network.Riak.Protocol.YzIndexGetResponse +import qualified Network.Riak.Protocol.YzIndexPutRequest +import qualified Network.Riak.Protocol.YzSchema +import qualified Network.Riak.Protocol.YzSchemaGetRequest +import qualified Network.Riak.Protocol.YzSchemaGetResponse +import qualified Network.Riak.Protocol.YzSchemaPutRequest +main = pure () +makeLenses ''Network.Riak.Protocol.AuthRequest.AuthRequest +makeLenses ''Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem +makeLenses ''Network.Riak.Protocol.BucketProps.BucketProps +makeLenses ''Network.Riak.Protocol.CommitHook.CommitHook +makeLenses ''Network.Riak.Protocol.Content.Content +makeLenses ''Network.Riak.Protocol.CounterGetRequest.CounterGetRequest +makeLenses ''Network.Riak.Protocol.CounterGetResponse.CounterGetResponse +makeLenses ''Network.Riak.Protocol.CounterOp.CounterOp +makeLenses ''Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest +makeLenses ''Network.Riak.Protocol.CounterUpdateResponse.CounterUpdateResponse +makeLenses ''Network.Riak.Protocol.CSBucketRequest.CSBucketRequest +makeLenses ''Network.Riak.Protocol.CSBucketResponse.CSBucketResponse +makeLenses ''Network.Riak.Protocol.DeleteRequest.DeleteRequest +makeLenses ''Network.Riak.Protocol.DtFetchRequest.DtFetchRequest +makeLenses ''Network.Riak.Protocol.DtFetchResponse.DtFetchResponse +makeLenses ''Network.Riak.Protocol.DtOp.DtOp +makeLenses ''Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest +makeLenses ''Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse +makeLenses ''Network.Riak.Protocol.DtValue.DtValue +makeLenses ''Network.Riak.Protocol.ErrorResponse.ErrorResponse +makeLenses ''Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest +makeLenses ''Network.Riak.Protocol.GetBucketKeyPreflistResponse.GetBucketKeyPreflistResponse +makeLenses ''Network.Riak.Protocol.GetBucketRequest.GetBucketRequest +makeLenses ''Network.Riak.Protocol.GetBucketResponse.GetBucketResponse +makeLenses ''Network.Riak.Protocol.GetBucketTypeRequest.GetBucketTypeRequest +makeLenses ''Network.Riak.Protocol.GetClientIDRequest.GetClientIDRequest +makeLenses ''Network.Riak.Protocol.GetClientIDResponse.GetClientIDResponse +makeLenses ''Network.Riak.Protocol.GetRequest.GetRequest +makeLenses ''Network.Riak.Protocol.GetResponse.GetResponse +makeLenses ''Network.Riak.Protocol.GetServerInfoRequest.GetServerInfoRequest +makeLenses ''Network.Riak.Protocol.IndexObject.IndexObject +makeLenses ''Network.Riak.Protocol.IndexRequest.IndexRequest +makeLenses ''Network.Riak.Protocol.IndexResponse.IndexResponse +makeLenses ''Network.Riak.Protocol.Link.Link +makeLenses ''Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest +makeLenses ''Network.Riak.Protocol.ListBucketsResponse.ListBucketsResponse +makeLenses ''Network.Riak.Protocol.ListKeysRequest.ListKeysRequest +makeLenses ''Network.Riak.Protocol.ListKeysResponse.ListKeysResponse +makeLenses ''Network.Riak.Protocol.MapEntry.MapEntry +makeLenses ''Network.Riak.Protocol.MapField.MapField +makeLenses ''Network.Riak.Protocol.MapField.MapFieldType.MapFieldType +makeLenses ''Network.Riak.Protocol.MapOp.MapOp +makeLenses ''Network.Riak.Protocol.MapReduce.MapReduce +makeLenses ''Network.Riak.Protocol.MapReduceRequest.MapReduceRequest +makeLenses ''Network.Riak.Protocol.MapUpdate.MapUpdate +makeLenses ''Network.Riak.Protocol.MapUpdate.FlagOp.FlagOp +makeLenses ''Network.Riak.Protocol.ModFun.ModFun +makeLenses ''Network.Riak.Protocol.Pair.Pair +makeLenses ''Network.Riak.Protocol.PingRequest.PingRequest +makeLenses ''Network.Riak.Protocol.PutRequest.PutRequest +makeLenses ''Network.Riak.Protocol.PutResponse.PutResponse +makeLenses ''Network.Riak.Protocol.ResetBucketRequest.ResetBucketRequest +makeLenses ''Network.Riak.Protocol.SearchDoc.SearchDoc +makeLenses ''Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest +makeLenses ''Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse +makeLenses ''Network.Riak.Protocol.ServerInfo.ServerInfo +makeLenses ''Network.Riak.Protocol.SetBucketRequest.SetBucketRequest +makeLenses ''Network.Riak.Protocol.SetBucketTypeRequest.SetBucketTypeRequest +makeLenses ''Network.Riak.Protocol.SetClientIDRequest.SetClientIDRequest +makeLenses ''Network.Riak.Protocol.SetOp.SetOp +makeLenses ''Network.Riak.Protocol.YzIndex.YzIndex +makeLenses ''Network.Riak.Protocol.YzIndexDeleteRequest.YzIndexDeleteRequest +makeLenses ''Network.Riak.Protocol.YzIndexGetRequest.YzIndexGetRequest +makeLenses ''Network.Riak.Protocol.YzIndexGetResponse.YzIndexGetResponse +makeLenses ''Network.Riak.Protocol.YzIndexPutRequest.YzIndexPutRequest +makeLenses ''Network.Riak.Protocol.YzSchema.YzSchema +makeLenses ''Network.Riak.Protocol.YzSchemaGetRequest.YzSchemaGetRequest +makeLenses ''Network.Riak.Protocol.YzSchemaGetResponse.YzSchemaGetResponse +makeLenses ''Network.Riak.Protocol.YzSchemaPutRequest.YzSchemaPutRequest diff --git a/app/TH.hs b/app/TH.hs new file mode 100644 --- /dev/null +++ b/app/TH.hs @@ -0,0 +1,26 @@ +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE ViewPatterns #-} + +module TH where + +import Data.Char (toUpper) +import Language.Haskell.TH.Lib (DecsQ) +import Language.Haskell.TH.Syntax +import Lens.Micro +import Lens.Micro.TH hiding (makeLenses) + +makeLenses :: Name -> DecsQ +makeLenses = + makeLensesWith + (camelCaseFields & set lensField + (\_ _ (nameBase -> field@(x:xs)) -> + let + className :: String + className = "Has" ++ (toUpper x : camel xs) + + camel :: String -> String + camel "" = "" + camel ('_':y:ys) = toUpper y : camel ys + camel (y:ys) = y : camel ys + in + [MethodName (mkName className) (mkName field)])) diff --git a/generate.sh b/generate.sh new file mode 100644 --- /dev/null +++ b/generate.sh @@ -0,0 +1,109 @@ +#!/bin/bash + +MAKE_LENSES_FILE=app/MakeLenses.hs +LENS_FILE=src/Network/Riak/Protocol/Lens.hs + +rm -f $MAKE_LENSES_FILE +rm -f $LENS_FILE + +EXTENSIONS=( + "{-# LANGUAGE FlexibleInstances #-}" + "{-# LANGUAGE FunctionalDependencies #-}" + "{-# LANGUAGE MultiParamTypeClasses #-}" +) + +IMPORTS=( + "import Data.ByteString.Lazy (ByteString)" + "import Data.Sequence (Seq)" + "import GHC.Int (Int64)" + "import GHC.Word (Word32)" +) + +# Modules to generate lenses for. This is everything in Network.Riak.Protocol.*, +# except some modules are manually deleted because they don't contain any +# records to generate lenses for. +LENS_MODULES=$( \ + find ../protobuf/src/Network/Riak/Protocol -name \*.hs \ + | sed \ + -e '/BucketProps.ReplMode/d' \ + -e '/DtFetchResponse.DataType/d' \ + -e '/GetClientIdRequest/d' \ + -e '/IndexRequest.IndexQueryType/d' \ + -e 's:../protobuf/src/::' -e 's/.hs//' -e 's:/:.:g' \ + | sort \ + ) + +# All protobuf modules +ALL_MODULES=$( \ + find ../protobuf/src/Network/Riak/Protocol -name \*.hs \ + | sed -e 's:../protobuf/src/::' -e 's/.hs//' -e 's:/:.:g' \ + | sort \ + ) + + +################################################################################ +## Generate, build, and dump splices of MakeLenses.hs + +OUTFILE=$MAKE_LENSES_FILE + +echo "-- THIS FILE WAS AUTO-GENERATED BY ./generate.sh" >> $OUTFILE + +for extension in "${EXTENSIONS[@]}"; do + echo $extension >> $OUTFILE +done + +echo "{-# LANGUAGE TemplateHaskell #-}" >> $OUTFILE +echo "module Main where" >> $OUTFILE +echo "import TH" >> $OUTFILE +echo "import Lens.Micro (Lens')" >> $OUTFILE + +for import in "${IMPORTS[@]}"; do + echo $import >> $OUTFILE +done + +for module in $LENS_MODULES; do + echo "import qualified $module" >> $OUTFILE +done + +echo "main = pure ()" >> $OUTFILE + +for module in $LENS_MODULES; do + type=$(sed -e 's/.*\.\(.*\)$/\1/' <<< $module) + echo "makeLenses ''$module.$type" >> $OUTFILE +done + +stack build riak-protobuf-lens:exe:generate --ghc-options="-ddump-splices -dppr-cols=200" + +################################################################################ +## Generate and build Network.Riak.Protocol.Lens with the dumped splices + +OUTFILE=$LENS_FILE + +echo "-- THIS FILE WAS AUTO-GENERATED BY ./generate.sh" >> $OUTFILE + +for extension in "${EXTENSIONS[@]}"; do + echo $extension >> $OUTFILE +done + +echo "{-# LANGUAGE RankNTypes #-}" >> $OUTFILE +echo "module Network.Riak.Protocol.Lens where" >> $OUTFILE + +for import in "${IMPORTS[@]}"; do + echo $import >> $OUTFILE +done + +for module in $ALL_MODULES; do + echo "import qualified $module" >> $OUTFILE +done + +echo "type Lens' s a = forall f. Functor f => (a -> f a) -> s -> f s" >> $OUTFILE + +cat $(stack path --dist-dir)/build/generate/generate-tmp/app/MakeLenses.dump-splices \ + | sed \ + -e '/app\/MakeLenses\.hs/d' \ + -e '/makeLenses/d' \ + -e '/======>/d' \ + -e 's/^ //' \ + >> $OUTFILE + +stack build diff --git a/riak-protobuf-lens.cabal b/riak-protobuf-lens.cabal new file mode 100644 --- /dev/null +++ b/riak-protobuf-lens.cabal @@ -0,0 +1,56 @@ +-- This file has been generated from package.yaml by hpack version 0.17.1. +-- +-- see: https://github.com/sol/hpack + +name: riak-protobuf-lens +version: 0.22.0.0 +synopsis: Lenses for riak-protobuf +description: + A set of Haskell lenses for interacting with the protocol buffer + API of the Riak decentralized data store. +category: Network +homepage: https://github.com/riak-haskell-client/riak-haskell-client#readme +bug-reports: https://github.com/riak-haskell-client/riak-haskell-client/issues +maintainer: Tim McGilchrist , Mitchell Rosen +license: OtherLicense +license-file: LICENSE +build-type: Simple +cabal-version: >= 1.10 + +extra-source-files: + Changes.md + generate.sh + README.markdown + +source-repository head + type: git + location: https://github.com/riak-haskell-client/riak-haskell-client + subdir: protobuf-lens + +library + hs-source-dirs: + src + build-depends: + base >= 3 && <5 + , bytestring + , containers + , riak-protobuf ==0.22.* + exposed-modules: + Network.Riak.Protocol.Lens + default-language: Haskell2010 + +executable generate + main-is: MakeLenses.hs + hs-source-dirs: + app + build-depends: + base >= 3 && <5 + , bytestring + , containers + , microlens <0.5 + , microlens-th <0.5 + , riak-protobuf ==0.22.* + , template-haskell + other-modules: + TH + default-language: Haskell2010 diff --git a/src/Network/Riak/Protocol/Lens.hs b/src/Network/Riak/Protocol/Lens.hs new file mode 100644 --- /dev/null +++ b/src/Network/Riak/Protocol/Lens.hs @@ -0,0 +1,4568 @@ +-- THIS FILE WAS AUTO-GENERATED BY ./generate.sh +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE FunctionalDependencies #-} +{-# LANGUAGE MultiParamTypeClasses #-} +{-# LANGUAGE RankNTypes #-} +module Network.Riak.Protocol.Lens where +import Data.ByteString.Lazy (ByteString) +import Data.Sequence (Seq) +import GHC.Int (Int64) +import GHC.Word (Word32) +import qualified Network.Riak.Protocol.AuthRequest +import qualified Network.Riak.Protocol.BucketKeyPreflistItem +import qualified Network.Riak.Protocol.BucketProps +import qualified Network.Riak.Protocol.BucketProps.ReplMode +import qualified Network.Riak.Protocol.CommitHook +import qualified Network.Riak.Protocol.Content +import qualified Network.Riak.Protocol.CounterGetRequest +import qualified Network.Riak.Protocol.CounterGetResponse +import qualified Network.Riak.Protocol.CounterOp +import qualified Network.Riak.Protocol.CounterUpdateRequest +import qualified Network.Riak.Protocol.CounterUpdateResponse +import qualified Network.Riak.Protocol.CSBucketRequest +import qualified Network.Riak.Protocol.CSBucketResponse +import qualified Network.Riak.Protocol.DeleteRequest +import qualified Network.Riak.Protocol.DtFetchRequest +import qualified Network.Riak.Protocol.DtFetchResponse +import qualified Network.Riak.Protocol.DtFetchResponse.DataType +import qualified Network.Riak.Protocol.DtOp +import qualified Network.Riak.Protocol.DtUpdateRequest +import qualified Network.Riak.Protocol.DtUpdateResponse +import qualified Network.Riak.Protocol.DtValue +import qualified Network.Riak.Protocol.ErrorResponse +import qualified Network.Riak.Protocol.GetBucketKeyPreflistRequest +import qualified Network.Riak.Protocol.GetBucketKeyPreflistResponse +import qualified Network.Riak.Protocol.GetBucketRequest +import qualified Network.Riak.Protocol.GetBucketResponse +import qualified Network.Riak.Protocol.GetBucketTypeRequest +import qualified Network.Riak.Protocol.GetClientIDRequest +import qualified Network.Riak.Protocol.GetClientIDResponse +import qualified Network.Riak.Protocol.GetRequest +import qualified Network.Riak.Protocol.GetResponse +import qualified Network.Riak.Protocol.GetServerInfoRequest +import qualified Network.Riak.Protocol.IndexObject +import qualified Network.Riak.Protocol.IndexRequest +import qualified Network.Riak.Protocol.IndexRequest.IndexQueryType +import qualified Network.Riak.Protocol.IndexResponse +import qualified Network.Riak.Protocol.Link +import qualified Network.Riak.Protocol.ListBucketsRequest +import qualified Network.Riak.Protocol.ListBucketsResponse +import qualified Network.Riak.Protocol.ListKeysRequest +import qualified Network.Riak.Protocol.ListKeysResponse +import qualified Network.Riak.Protocol.MapEntry +import qualified Network.Riak.Protocol.MapField +import qualified Network.Riak.Protocol.MapField.MapFieldType +import qualified Network.Riak.Protocol.MapOp +import qualified Network.Riak.Protocol.MapReduce +import qualified Network.Riak.Protocol.MapReduceRequest +import qualified Network.Riak.Protocol.MapUpdate +import qualified Network.Riak.Protocol.MapUpdate.FlagOp +import qualified Network.Riak.Protocol.ModFun +import qualified Network.Riak.Protocol.Pair +import qualified Network.Riak.Protocol.PingRequest +import qualified Network.Riak.Protocol.PutRequest +import qualified Network.Riak.Protocol.PutResponse +import qualified Network.Riak.Protocol.ResetBucketRequest +import qualified Network.Riak.Protocol.SearchDoc +import qualified Network.Riak.Protocol.SearchQueryRequest +import qualified Network.Riak.Protocol.SearchQueryResponse +import qualified Network.Riak.Protocol.ServerInfo +import qualified Network.Riak.Protocol.SetBucketRequest +import qualified Network.Riak.Protocol.SetBucketTypeRequest +import qualified Network.Riak.Protocol.SetClientIDRequest +import qualified Network.Riak.Protocol.SetOp +import qualified Network.Riak.Protocol.YzIndex +import qualified Network.Riak.Protocol.YzIndexDeleteRequest +import qualified Network.Riak.Protocol.YzIndexGetRequest +import qualified Network.Riak.Protocol.YzIndexGetResponse +import qualified Network.Riak.Protocol.YzIndexPutRequest +import qualified Network.Riak.Protocol.YzSchema +import qualified Network.Riak.Protocol.YzSchemaGetRequest +import qualified Network.Riak.Protocol.YzSchemaGetResponse +import qualified Network.Riak.Protocol.YzSchemaPutRequest +type Lens' s a = forall f. Functor f => (a -> f a) -> s -> f s +class HasPassword s a | s -> a where + password :: Lens' s a +instance HasPassword Network.Riak.Protocol.AuthRequest.AuthRequest ByteString where + {-# INLINE password #-} + password f_agC6 (Network.Riak.Protocol.AuthRequest.AuthRequest x_agC7 x_agC8) + = fmap (\ y_agC9 -> Network.Riak.Protocol.AuthRequest.AuthRequest x_agC7 y_agC9) (f_agC6 x_agC8) +class HasUser s a | s -> a where + user :: Lens' s a +instance HasUser Network.Riak.Protocol.AuthRequest.AuthRequest ByteString where + {-# INLINE user #-} + user f_agCa (Network.Riak.Protocol.AuthRequest.AuthRequest x_agCb x_agCc) + = fmap (\ y_agCd -> Network.Riak.Protocol.AuthRequest.AuthRequest y_agCd x_agCc) (f_agCa x_agCb) +class HasNode s a | s -> a where + node :: Lens' s a +instance HasNode Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem ByteString where + {-# INLINE node #-} + node f_agE6 (Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem x_agE7 x_agE8 x_agE9) + = fmap (\ y_agEa -> Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem x_agE7 y_agEa x_agE9) (f_agE6 x_agE8) +class HasPartition s a | s -> a where + partition :: Lens' s a +instance HasPartition Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem Int64 where + {-# INLINE partition #-} + partition f_agEb (Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem x_agEc x_agEd x_agEe) + = fmap (\ y_agEf -> Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem y_agEf x_agEd x_agEe) (f_agEb x_agEc) +class HasPrimary s a | s -> a where + primary :: Lens' s a +instance HasPrimary Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem Bool where + {-# INLINE primary #-} + primary f_agEg (Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem x_agEh x_agEi x_agEj) + = fmap (\ y_agEk -> Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem x_agEh x_agEi y_agEk) (f_agEg x_agEj) +class HasAllowMult s a | s -> a where + allow_mult :: Lens' s a +instance HasAllowMult Network.Riak.Protocol.BucketProps.BucketProps (Maybe Bool) where + {-# INLINE allow_mult #-} + allow_mult + f_agGs + (Network.Riak.Protocol.BucketProps.BucketProps x_agGt + x_agGu + x_agGv + x_agGw + x_agGx + x_agGy + x_agGz + x_agGA + x_agGB + x_agGC + x_agGD + x_agGE + x_agGF + x_agGG + x_agGH + x_agGI + x_agGJ + x_agGK + x_agGL + x_agGM + x_agGN + x_agGO + x_agGP + x_agGQ + x_agGR + x_agGS + x_agGT + x_agGU) + = fmap + (\ y_agGV + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agGt + y_agGV + x_agGv + x_agGw + x_agGx + x_agGy + x_agGz + x_agGA + x_agGB + x_agGC + x_agGD + x_agGE + x_agGF + x_agGG + x_agGH + x_agGI + x_agGJ + x_agGK + x_agGL + x_agGM + x_agGN + x_agGO + x_agGP + x_agGQ + x_agGR + x_agGS + x_agGT + x_agGU) + (f_agGs x_agGu) +class HasBackend s a | s -> a where + backend :: Lens' s a +instance HasBackend Network.Riak.Protocol.BucketProps.BucketProps (Maybe ByteString) where + {-# INLINE backend #-} + backend + f_agGW + (Network.Riak.Protocol.BucketProps.BucketProps x_agGX + x_agGY + x_agGZ + x_agH0 + x_agH1 + x_agH2 + x_agH3 + x_agH4 + x_agH5 + x_agH6 + x_agH7 + x_agH8 + x_agH9 + x_agHa + x_agHb + x_agHc + x_agHd + x_agHe + x_agHf + x_agHg + x_agHh + x_agHi + x_agHj + x_agHk + x_agHl + x_agHm + x_agHn + x_agHo) + = fmap + (\ y_agHp + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agGX + x_agGY + x_agGZ + x_agH0 + x_agH1 + x_agH2 + x_agH3 + x_agH4 + x_agH5 + x_agH6 + x_agH7 + x_agH8 + x_agH9 + x_agHa + x_agHb + x_agHc + x_agHd + x_agHe + x_agHf + x_agHg + x_agHh + y_agHp + x_agHj + x_agHk + x_agHl + x_agHm + x_agHn + x_agHo) + (f_agGW x_agHi) +class HasBasicQuorum s a | s -> a where + basic_quorum :: Lens' s a +instance HasBasicQuorum Network.Riak.Protocol.BucketProps.BucketProps (Maybe Bool) where + {-# INLINE basic_quorum #-} + basic_quorum + f_agHq + (Network.Riak.Protocol.BucketProps.BucketProps x_agHr + x_agHs + x_agHt + x_agHu + x_agHv + x_agHw + x_agHx + x_agHy + x_agHz + x_agHA + x_agHB + x_agHC + x_agHD + x_agHE + x_agHF + x_agHG + x_agHH + x_agHI + x_agHJ + x_agHK + x_agHL + x_agHM + x_agHN + x_agHO + x_agHP + x_agHQ + x_agHR + x_agHS) + = fmap + (\ y_agHT + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agHr + x_agHs + x_agHt + x_agHu + x_agHv + x_agHw + x_agHx + x_agHy + x_agHz + x_agHA + x_agHB + x_agHC + x_agHD + x_agHE + x_agHF + x_agHG + x_agHH + x_agHI + x_agHJ + y_agHT + x_agHL + x_agHM + x_agHN + x_agHO + x_agHP + x_agHQ + x_agHR + x_agHS) + (f_agHq x_agHK) +class HasBigVclock s a | s -> a where + big_vclock :: Lens' s a +instance HasBigVclock Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE big_vclock #-} + big_vclock + f_agHU + (Network.Riak.Protocol.BucketProps.BucketProps x_agHV + x_agHW + x_agHX + x_agHY + x_agHZ + x_agI0 + x_agI1 + x_agI2 + x_agI3 + x_agI4 + x_agI5 + x_agI6 + x_agI7 + x_agI8 + x_agI9 + x_agIa + x_agIb + x_agIc + x_agId + x_agIe + x_agIf + x_agIg + x_agIh + x_agIi + x_agIj + x_agIk + x_agIl + x_agIm) + = fmap + (\ y_agIn + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agHV + x_agHW + x_agHX + x_agHY + x_agHZ + x_agI0 + x_agI1 + x_agI2 + x_agI3 + x_agI4 + x_agI5 + y_agIn + x_agI7 + x_agI8 + x_agI9 + x_agIa + x_agIb + x_agIc + x_agId + x_agIe + x_agIf + x_agIg + x_agIh + x_agIi + x_agIj + x_agIk + x_agIl + x_agIm) + (f_agHU x_agI6) +class HasChashKeyfun s a | s -> a where + chash_keyfun :: Lens' s a +instance HasChashKeyfun Network.Riak.Protocol.BucketProps.BucketProps (Maybe Network.Riak.Protocol.ModFun.ModFun) where + {-# INLINE chash_keyfun #-} + chash_keyfun + f_agIo + (Network.Riak.Protocol.BucketProps.BucketProps x_agIp + x_agIq + x_agIr + x_agIs + x_agIt + x_agIu + x_agIv + x_agIw + x_agIx + x_agIy + x_agIz + x_agIA + x_agIB + x_agIC + x_agID + x_agIE + x_agIF + x_agIG + x_agIH + x_agII + x_agIJ + x_agIK + x_agIL + x_agIM + x_agIN + x_agIO + x_agIP + x_agIQ) + = fmap + (\ y_agIR + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agIp + x_agIq + x_agIr + x_agIs + x_agIt + x_agIu + x_agIv + y_agIR + x_agIx + x_agIy + x_agIz + x_agIA + x_agIB + x_agIC + x_agID + x_agIE + x_agIF + x_agIG + x_agIH + x_agII + x_agIJ + x_agIK + x_agIL + x_agIM + x_agIN + x_agIO + x_agIP + x_agIQ) + (f_agIo x_agIw) +class HasConsistent s a | s -> a where + consistent :: Lens' s a +instance HasConsistent Network.Riak.Protocol.BucketProps.BucketProps (Maybe Bool) where + {-# INLINE consistent #-} + consistent + f_agIS + (Network.Riak.Protocol.BucketProps.BucketProps x_agIT + x_agIU + x_agIV + x_agIW + x_agIX + x_agIY + x_agIZ + x_agJ0 + x_agJ1 + x_agJ2 + x_agJ3 + x_agJ4 + x_agJ5 + x_agJ6 + x_agJ7 + x_agJ8 + x_agJ9 + x_agJa + x_agJb + x_agJc + x_agJd + x_agJe + x_agJf + x_agJg + x_agJh + x_agJi + x_agJj + x_agJk) + = fmap + (\ y_agJl + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agIT + x_agIU + x_agIV + x_agIW + x_agIX + x_agIY + x_agIZ + x_agJ0 + x_agJ1 + x_agJ2 + x_agJ3 + x_agJ4 + x_agJ5 + x_agJ6 + x_agJ7 + x_agJ8 + x_agJ9 + x_agJa + x_agJb + x_agJc + x_agJd + x_agJe + x_agJf + x_agJg + x_agJh + x_agJi + y_agJl + x_agJk) + (f_agIS x_agJj) +class HasDatatype s a | s -> a where + datatype :: Lens' s a +instance HasDatatype Network.Riak.Protocol.BucketProps.BucketProps (Maybe ByteString) where + {-# INLINE datatype #-} + datatype + f_agJm + (Network.Riak.Protocol.BucketProps.BucketProps x_agJn + x_agJo + x_agJp + x_agJq + x_agJr + x_agJs + x_agJt + x_agJu + x_agJv + x_agJw + x_agJx + x_agJy + x_agJz + x_agJA + x_agJB + x_agJC + x_agJD + x_agJE + x_agJF + x_agJG + x_agJH + x_agJI + x_agJJ + x_agJK + x_agJL + x_agJM + x_agJN + x_agJO) + = fmap + (\ y_agJP + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agJn + x_agJo + x_agJp + x_agJq + x_agJr + x_agJs + x_agJt + x_agJu + x_agJv + x_agJw + x_agJx + x_agJy + x_agJz + x_agJA + x_agJB + x_agJC + x_agJD + x_agJE + x_agJF + x_agJG + x_agJH + x_agJI + x_agJJ + x_agJK + x_agJL + y_agJP + x_agJN + x_agJO) + (f_agJm x_agJM) +class HasDw s a | s -> a where + dw :: Lens' s a +instance HasDw Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE dw #-} + dw + f_agJQ + (Network.Riak.Protocol.BucketProps.BucketProps x_agJR + x_agJS + x_agJT + x_agJU + x_agJV + x_agJW + x_agJX + x_agJY + x_agJZ + x_agK0 + x_agK1 + x_agK2 + x_agK3 + x_agK4 + x_agK5 + x_agK6 + x_agK7 + x_agK8 + x_agK9 + x_agKa + x_agKb + x_agKc + x_agKd + x_agKe + x_agKf + x_agKg + x_agKh + x_agKi) + = fmap + (\ y_agKj + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agJR + x_agJS + x_agJT + x_agJU + x_agJV + x_agJW + x_agJX + x_agJY + x_agJZ + x_agK0 + x_agK1 + x_agK2 + x_agK3 + x_agK4 + x_agK5 + x_agK6 + x_agK7 + y_agKj + x_agK9 + x_agKa + x_agKb + x_agKc + x_agKd + x_agKe + x_agKf + x_agKg + x_agKh + x_agKi) + (f_agJQ x_agK8) +class HasHasPostcommit s a | s -> a where + has_postcommit :: Lens' s a +instance HasHasPostcommit Network.Riak.Protocol.BucketProps.BucketProps (Maybe Bool) where + {-# INLINE has_postcommit #-} + has_postcommit + f_agKk + (Network.Riak.Protocol.BucketProps.BucketProps x_agKl + x_agKm + x_agKn + x_agKo + x_agKp + x_agKq + x_agKr + x_agKs + x_agKt + x_agKu + x_agKv + x_agKw + x_agKx + x_agKy + x_agKz + x_agKA + x_agKB + x_agKC + x_agKD + x_agKE + x_agKF + x_agKG + x_agKH + x_agKI + x_agKJ + x_agKK + x_agKL + x_agKM) + = fmap + (\ y_agKN + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agKl + x_agKm + x_agKn + x_agKo + x_agKp + x_agKq + y_agKN + x_agKs + x_agKt + x_agKu + x_agKv + x_agKw + x_agKx + x_agKy + x_agKz + x_agKA + x_agKB + x_agKC + x_agKD + x_agKE + x_agKF + x_agKG + x_agKH + x_agKI + x_agKJ + x_agKK + x_agKL + x_agKM) + (f_agKk x_agKr) +class HasHasPrecommit s a | s -> a where + has_precommit :: Lens' s a +instance HasHasPrecommit Network.Riak.Protocol.BucketProps.BucketProps (Maybe Bool) where + {-# INLINE has_precommit #-} + has_precommit + f_agKO + (Network.Riak.Protocol.BucketProps.BucketProps x_agKP + x_agKQ + x_agKR + x_agKS + x_agKT + x_agKU + x_agKV + x_agKW + x_agKX + x_agKY + x_agKZ + x_agL0 + x_agL1 + x_agL2 + x_agL3 + x_agL4 + x_agL5 + x_agL6 + x_agL7 + x_agL8 + x_agL9 + x_agLa + x_agLb + x_agLc + x_agLd + x_agLe + x_agLf + x_agLg) + = fmap + (\ y_agLh + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agKP + x_agKQ + x_agKR + x_agKS + y_agLh + x_agKU + x_agKV + x_agKW + x_agKX + x_agKY + x_agKZ + x_agL0 + x_agL1 + x_agL2 + x_agL3 + x_agL4 + x_agL5 + x_agL6 + x_agL7 + x_agL8 + x_agL9 + x_agLa + x_agLb + x_agLc + x_agLd + x_agLe + x_agLf + x_agLg) + (f_agKO x_agKT) +class HasLastWriteWins s a | s -> a where + last_write_wins :: Lens' s a +instance HasLastWriteWins Network.Riak.Protocol.BucketProps.BucketProps (Maybe Bool) where + {-# INLINE last_write_wins #-} + last_write_wins + f_agLi + (Network.Riak.Protocol.BucketProps.BucketProps x_agLj + x_agLk + x_agLl + x_agLm + x_agLn + x_agLo + x_agLp + x_agLq + x_agLr + x_agLs + x_agLt + x_agLu + x_agLv + x_agLw + x_agLx + x_agLy + x_agLz + x_agLA + x_agLB + x_agLC + x_agLD + x_agLE + x_agLF + x_agLG + x_agLH + x_agLI + x_agLJ + x_agLK) + = fmap + (\ y_agLL + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agLj + x_agLk + y_agLL + x_agLm + x_agLn + x_agLo + x_agLp + x_agLq + x_agLr + x_agLs + x_agLt + x_agLu + x_agLv + x_agLw + x_agLx + x_agLy + x_agLz + x_agLA + x_agLB + x_agLC + x_agLD + x_agLE + x_agLF + x_agLG + x_agLH + x_agLI + x_agLJ + x_agLK) + (f_agLi x_agLl) +class HasLinkfun s a | s -> a where + linkfun :: Lens' s a +instance HasLinkfun Network.Riak.Protocol.BucketProps.BucketProps (Maybe Network.Riak.Protocol.ModFun.ModFun) where + {-# INLINE linkfun #-} + linkfun + f_agLM + (Network.Riak.Protocol.BucketProps.BucketProps x_agLN + x_agLO + x_agLP + x_agLQ + x_agLR + x_agLS + x_agLT + x_agLU + x_agLV + x_agLW + x_agLX + x_agLY + x_agLZ + x_agM0 + x_agM1 + x_agM2 + x_agM3 + x_agM4 + x_agM5 + x_agM6 + x_agM7 + x_agM8 + x_agM9 + x_agMa + x_agMb + x_agMc + x_agMd + x_agMe) + = fmap + (\ y_agMf + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agLN + x_agLO + x_agLP + x_agLQ + x_agLR + x_agLS + x_agLT + x_agLU + y_agMf + x_agLW + x_agLX + x_agLY + x_agLZ + x_agM0 + x_agM1 + x_agM2 + x_agM3 + x_agM4 + x_agM5 + x_agM6 + x_agM7 + x_agM8 + x_agM9 + x_agMa + x_agMb + x_agMc + x_agMd + x_agMe) + (f_agLM x_agLV) +class HasNVal s a | s -> a where + n_val :: Lens' s a +instance HasNVal Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE n_val #-} + n_val + f_agMg + (Network.Riak.Protocol.BucketProps.BucketProps x_agMh + x_agMi + x_agMj + x_agMk + x_agMl + x_agMm + x_agMn + x_agMo + x_agMp + x_agMq + x_agMr + x_agMs + x_agMt + x_agMu + x_agMv + x_agMw + x_agMx + x_agMy + x_agMz + x_agMA + x_agMB + x_agMC + x_agMD + x_agME + x_agMF + x_agMG + x_agMH + x_agMI) + = fmap + (\ y_agMJ + -> Network.Riak.Protocol.BucketProps.BucketProps + y_agMJ + x_agMi + x_agMj + x_agMk + x_agMl + x_agMm + x_agMn + x_agMo + x_agMp + x_agMq + x_agMr + x_agMs + x_agMt + x_agMu + x_agMv + x_agMw + x_agMx + x_agMy + x_agMz + x_agMA + x_agMB + x_agMC + x_agMD + x_agME + x_agMF + x_agMG + x_agMH + x_agMI) + (f_agMg x_agMh) +class HasNotfoundOk s a | s -> a where + notfound_ok :: Lens' s a +instance HasNotfoundOk Network.Riak.Protocol.BucketProps.BucketProps (Maybe Bool) where + {-# INLINE notfound_ok #-} + notfound_ok + f_agMK + (Network.Riak.Protocol.BucketProps.BucketProps x_agML + x_agMM + x_agMN + x_agMO + x_agMP + x_agMQ + x_agMR + x_agMS + x_agMT + x_agMU + x_agMV + x_agMW + x_agMX + x_agMY + x_agMZ + x_agN0 + x_agN1 + x_agN2 + x_agN3 + x_agN4 + x_agN5 + x_agN6 + x_agN7 + x_agN8 + x_agN9 + x_agNa + x_agNb + x_agNc) + = fmap + (\ y_agNd + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agML + x_agMM + x_agMN + x_agMO + x_agMP + x_agMQ + x_agMR + x_agMS + x_agMT + x_agMU + x_agMV + x_agMW + x_agMX + x_agMY + x_agMZ + x_agN0 + x_agN1 + x_agN2 + x_agN3 + x_agN4 + y_agNd + x_agN6 + x_agN7 + x_agN8 + x_agN9 + x_agNa + x_agNb + x_agNc) + (f_agMK x_agN5) +class HasOldVclock s a | s -> a where + old_vclock :: Lens' s a +instance HasOldVclock Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE old_vclock #-} + old_vclock + f_agNe + (Network.Riak.Protocol.BucketProps.BucketProps x_agNf + x_agNg + x_agNh + x_agNi + x_agNj + x_agNk + x_agNl + x_agNm + x_agNn + x_agNo + x_agNp + x_agNq + x_agNr + x_agNs + x_agNt + x_agNu + x_agNv + x_agNw + x_agNx + x_agNy + x_agNz + x_agNA + x_agNB + x_agNC + x_agND + x_agNE + x_agNF + x_agNG) + = fmap + (\ y_agNH + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agNf + x_agNg + x_agNh + x_agNi + x_agNj + x_agNk + x_agNl + x_agNm + x_agNn + y_agNH + x_agNp + x_agNq + x_agNr + x_agNs + x_agNt + x_agNu + x_agNv + x_agNw + x_agNx + x_agNy + x_agNz + x_agNA + x_agNB + x_agNC + x_agND + x_agNE + x_agNF + x_agNG) + (f_agNe x_agNo) +class HasPostcommit s a | s -> a where + postcommit :: Lens' s a +instance HasPostcommit Network.Riak.Protocol.BucketProps.BucketProps (Seq Network.Riak.Protocol.CommitHook.CommitHook) where + {-# INLINE postcommit #-} + postcommit + f_agNI + (Network.Riak.Protocol.BucketProps.BucketProps x_agNJ + x_agNK + x_agNL + x_agNM + x_agNN + x_agNO + x_agNP + x_agNQ + x_agNR + x_agNS + x_agNT + x_agNU + x_agNV + x_agNW + x_agNX + x_agNY + x_agNZ + x_agO0 + x_agO1 + x_agO2 + x_agO3 + x_agO4 + x_agO5 + x_agO6 + x_agO7 + x_agO8 + x_agO9 + x_agOa) + = fmap + (\ y_agOb + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agNJ + x_agNK + x_agNL + x_agNM + x_agNN + y_agOb + x_agNP + x_agNQ + x_agNR + x_agNS + x_agNT + x_agNU + x_agNV + x_agNW + x_agNX + x_agNY + x_agNZ + x_agO0 + x_agO1 + x_agO2 + x_agO3 + x_agO4 + x_agO5 + x_agO6 + x_agO7 + x_agO8 + x_agO9 + x_agOa) + (f_agNI x_agNO) +class HasPr s a | s -> a where + pr :: Lens' s a +instance HasPr Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE pr #-} + pr + f_agOc + (Network.Riak.Protocol.BucketProps.BucketProps x_agOd + x_agOe + x_agOf + x_agOg + x_agOh + x_agOi + x_agOj + x_agOk + x_agOl + x_agOm + x_agOn + x_agOo + x_agOp + x_agOq + x_agOr + x_agOs + x_agOt + x_agOu + x_agOv + x_agOw + x_agOx + x_agOy + x_agOz + x_agOA + x_agOB + x_agOC + x_agOD + x_agOE) + = fmap + (\ y_agOF + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agOd + x_agOe + x_agOf + x_agOg + x_agOh + x_agOi + x_agOj + x_agOk + x_agOl + x_agOm + x_agOn + x_agOo + x_agOp + y_agOF + x_agOr + x_agOs + x_agOt + x_agOu + x_agOv + x_agOw + x_agOx + x_agOy + x_agOz + x_agOA + x_agOB + x_agOC + x_agOD + x_agOE) + (f_agOc x_agOq) +class HasPrecommit s a | s -> a where + precommit :: Lens' s a +instance HasPrecommit Network.Riak.Protocol.BucketProps.BucketProps (Seq Network.Riak.Protocol.CommitHook.CommitHook) where + {-# INLINE precommit #-} + precommit + f_agOG + (Network.Riak.Protocol.BucketProps.BucketProps x_agOH + x_agOI + x_agOJ + x_agOK + x_agOL + x_agOM + x_agON + x_agOO + x_agOP + x_agOQ + x_agOR + x_agOS + x_agOT + x_agOU + x_agOV + x_agOW + x_agOX + x_agOY + x_agOZ + x_agP0 + x_agP1 + x_agP2 + x_agP3 + x_agP4 + x_agP5 + x_agP6 + x_agP7 + x_agP8) + = fmap + (\ y_agP9 + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agOH + x_agOI + x_agOJ + y_agP9 + x_agOL + x_agOM + x_agON + x_agOO + x_agOP + x_agOQ + x_agOR + x_agOS + x_agOT + x_agOU + x_agOV + x_agOW + x_agOX + x_agOY + x_agOZ + x_agP0 + x_agP1 + x_agP2 + x_agP3 + x_agP4 + x_agP5 + x_agP6 + x_agP7 + x_agP8) + (f_agOG x_agOK) +class HasPw s a | s -> a where + pw :: Lens' s a +instance HasPw Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE pw #-} + pw + f_agPa + (Network.Riak.Protocol.BucketProps.BucketProps x_agPb + x_agPc + x_agPd + x_agPe + x_agPf + x_agPg + x_agPh + x_agPi + x_agPj + x_agPk + x_agPl + x_agPm + x_agPn + x_agPo + x_agPp + x_agPq + x_agPr + x_agPs + x_agPt + x_agPu + x_agPv + x_agPw + x_agPx + x_agPy + x_agPz + x_agPA + x_agPB + x_agPC) + = fmap + (\ y_agPD + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agPb + x_agPc + x_agPd + x_agPe + x_agPf + x_agPg + x_agPh + x_agPi + x_agPj + x_agPk + x_agPl + x_agPm + x_agPn + x_agPo + x_agPp + x_agPq + y_agPD + x_agPs + x_agPt + x_agPu + x_agPv + x_agPw + x_agPx + x_agPy + x_agPz + x_agPA + x_agPB + x_agPC) + (f_agPa x_agPr) +class HasR s a | s -> a where + r :: Lens' s a +instance HasR Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE r #-} + r f_agPE + (Network.Riak.Protocol.BucketProps.BucketProps x_agPF + x_agPG + x_agPH + x_agPI + x_agPJ + x_agPK + x_agPL + x_agPM + x_agPN + x_agPO + x_agPP + x_agPQ + x_agPR + x_agPS + x_agPT + x_agPU + x_agPV + x_agPW + x_agPX + x_agPY + x_agPZ + x_agQ0 + x_agQ1 + x_agQ2 + x_agQ3 + x_agQ4 + x_agQ5 + x_agQ6) + = fmap + (\ y_agQ7 + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agPF + x_agPG + x_agPH + x_agPI + x_agPJ + x_agPK + x_agPL + x_agPM + x_agPN + x_agPO + x_agPP + x_agPQ + x_agPR + x_agPS + y_agQ7 + x_agPU + x_agPV + x_agPW + x_agPX + x_agPY + x_agPZ + x_agQ0 + x_agQ1 + x_agQ2 + x_agQ3 + x_agQ4 + x_agQ5 + x_agQ6) + (f_agPE x_agPT) +class HasRepl s a | s -> a where + repl :: Lens' s a +instance HasRepl Network.Riak.Protocol.BucketProps.BucketProps (Maybe Network.Riak.Protocol.BucketProps.ReplMode.ReplMode) where + {-# INLINE repl #-} + repl + f_agQ8 + (Network.Riak.Protocol.BucketProps.BucketProps x_agQ9 + x_agQa + x_agQb + x_agQc + x_agQd + x_agQe + x_agQf + x_agQg + x_agQh + x_agQi + x_agQj + x_agQk + x_agQl + x_agQm + x_agQn + x_agQo + x_agQp + x_agQq + x_agQr + x_agQs + x_agQt + x_agQu + x_agQv + x_agQw + x_agQx + x_agQy + x_agQz + x_agQA) + = fmap + (\ y_agQB + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agQ9 + x_agQa + x_agQb + x_agQc + x_agQd + x_agQe + x_agQf + x_agQg + x_agQh + x_agQi + x_agQj + x_agQk + x_agQl + x_agQm + x_agQn + x_agQo + x_agQp + x_agQq + x_agQr + x_agQs + x_agQt + x_agQu + x_agQv + y_agQB + x_agQx + x_agQy + x_agQz + x_agQA) + (f_agQ8 x_agQw) +class HasRw s a | s -> a where + rw :: Lens' s a +instance HasRw Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE rw #-} + rw + f_agQC + (Network.Riak.Protocol.BucketProps.BucketProps x_agQD + x_agQE + x_agQF + x_agQG + x_agQH + x_agQI + x_agQJ + x_agQK + x_agQL + x_agQM + x_agQN + x_agQO + x_agQP + x_agQQ + x_agQR + x_agQS + x_agQT + x_agQU + x_agQV + x_agQW + x_agQX + x_agQY + x_agQZ + x_agR0 + x_agR1 + x_agR2 + x_agR3 + x_agR4) + = fmap + (\ y_agR5 + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agQD + x_agQE + x_agQF + x_agQG + x_agQH + x_agQI + x_agQJ + x_agQK + x_agQL + x_agQM + x_agQN + x_agQO + x_agQP + x_agQQ + x_agQR + x_agQS + x_agQT + x_agQU + y_agR5 + x_agQW + x_agQX + x_agQY + x_agQZ + x_agR0 + x_agR1 + x_agR2 + x_agR3 + x_agR4) + (f_agQC x_agQV) +class HasSearch s a | s -> a where + search :: Lens' s a +instance HasSearch Network.Riak.Protocol.BucketProps.BucketProps (Maybe Bool) where + {-# INLINE search #-} + search + f_agR6 + (Network.Riak.Protocol.BucketProps.BucketProps x_agR7 + x_agR8 + x_agR9 + x_agRa + x_agRb + x_agRc + x_agRd + x_agRe + x_agRf + x_agRg + x_agRh + x_agRi + x_agRj + x_agRk + x_agRl + x_agRm + x_agRn + x_agRo + x_agRp + x_agRq + x_agRr + x_agRs + x_agRt + x_agRu + x_agRv + x_agRw + x_agRx + x_agRy) + = fmap + (\ y_agRz + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agR7 + x_agR8 + x_agR9 + x_agRa + x_agRb + x_agRc + x_agRd + x_agRe + x_agRf + x_agRg + x_agRh + x_agRi + x_agRj + x_agRk + x_agRl + x_agRm + x_agRn + x_agRo + x_agRp + x_agRq + x_agRr + x_agRs + y_agRz + x_agRu + x_agRv + x_agRw + x_agRx + x_agRy) + (f_agR6 x_agRt) +class HasSearchIndex s a | s -> a where + search_index :: Lens' s a +instance HasSearchIndex Network.Riak.Protocol.BucketProps.BucketProps (Maybe ByteString) where + {-# INLINE search_index #-} + search_index + f_agRA + (Network.Riak.Protocol.BucketProps.BucketProps x_agRB + x_agRC + x_agRD + x_agRE + x_agRF + x_agRG + x_agRH + x_agRI + x_agRJ + x_agRK + x_agRL + x_agRM + x_agRN + x_agRO + x_agRP + x_agRQ + x_agRR + x_agRS + x_agRT + x_agRU + x_agRV + x_agRW + x_agRX + x_agRY + x_agRZ + x_agS0 + x_agS1 + x_agS2) + = fmap + (\ y_agS3 + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agRB + x_agRC + x_agRD + x_agRE + x_agRF + x_agRG + x_agRH + x_agRI + x_agRJ + x_agRK + x_agRL + x_agRM + x_agRN + x_agRO + x_agRP + x_agRQ + x_agRR + x_agRS + x_agRT + x_agRU + x_agRV + x_agRW + x_agRX + x_agRY + y_agS3 + x_agS0 + x_agS1 + x_agS2) + (f_agRA x_agRZ) +class HasSmallVclock s a | s -> a where + small_vclock :: Lens' s a +instance HasSmallVclock Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE small_vclock #-} + small_vclock + f_agS4 + (Network.Riak.Protocol.BucketProps.BucketProps x_agS5 + x_agS6 + x_agS7 + x_agS8 + x_agS9 + x_agSa + x_agSb + x_agSc + x_agSd + x_agSe + x_agSf + x_agSg + x_agSh + x_agSi + x_agSj + x_agSk + x_agSl + x_agSm + x_agSn + x_agSo + x_agSp + x_agSq + x_agSr + x_agSs + x_agSt + x_agSu + x_agSv + x_agSw) + = fmap + (\ y_agSx + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agS5 + x_agS6 + x_agS7 + x_agS8 + x_agS9 + x_agSa + x_agSb + x_agSc + x_agSd + x_agSe + x_agSf + x_agSg + y_agSx + x_agSi + x_agSj + x_agSk + x_agSl + x_agSm + x_agSn + x_agSo + x_agSp + x_agSq + x_agSr + x_agSs + x_agSt + x_agSu + x_agSv + x_agSw) + (f_agS4 x_agSh) +class HasW s a | s -> a where + w :: Lens' s a +instance HasW Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE w #-} + w f_agSy + (Network.Riak.Protocol.BucketProps.BucketProps x_agSz + x_agSA + x_agSB + x_agSC + x_agSD + x_agSE + x_agSF + x_agSG + x_agSH + x_agSI + x_agSJ + x_agSK + x_agSL + x_agSM + x_agSN + x_agSO + x_agSP + x_agSQ + x_agSR + x_agSS + x_agST + x_agSU + x_agSV + x_agSW + x_agSX + x_agSY + x_agSZ + x_agT0) + = fmap + (\ y_agT1 + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agSz + x_agSA + x_agSB + x_agSC + x_agSD + x_agSE + x_agSF + x_agSG + x_agSH + x_agSI + x_agSJ + x_agSK + x_agSL + x_agSM + x_agSN + y_agT1 + x_agSP + x_agSQ + x_agSR + x_agSS + x_agST + x_agSU + x_agSV + x_agSW + x_agSX + x_agSY + x_agSZ + x_agT0) + (f_agSy x_agSO) +class HasWriteOnce s a | s -> a where + write_once :: Lens' s a +instance HasWriteOnce Network.Riak.Protocol.BucketProps.BucketProps (Maybe Bool) where + {-# INLINE write_once #-} + write_once + f_agT2 + (Network.Riak.Protocol.BucketProps.BucketProps x_agT3 + x_agT4 + x_agT5 + x_agT6 + x_agT7 + x_agT8 + x_agT9 + x_agTa + x_agTb + x_agTc + x_agTd + x_agTe + x_agTf + x_agTg + x_agTh + x_agTi + x_agTj + x_agTk + x_agTl + x_agTm + x_agTn + x_agTo + x_agTp + x_agTq + x_agTr + x_agTs + x_agTt + x_agTu) + = fmap + (\ y_agTv + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agT3 + x_agT4 + x_agT5 + x_agT6 + x_agT7 + x_agT8 + x_agT9 + x_agTa + x_agTb + x_agTc + x_agTd + x_agTe + x_agTf + x_agTg + x_agTh + x_agTi + x_agTj + x_agTk + x_agTl + x_agTm + x_agTn + x_agTo + x_agTp + x_agTq + x_agTr + x_agTs + x_agTt + y_agTv) + (f_agT2 x_agTu) +class HasYoungVclock s a | s -> a where + young_vclock :: Lens' s a +instance HasYoungVclock Network.Riak.Protocol.BucketProps.BucketProps (Maybe Word32) where + {-# INLINE young_vclock #-} + young_vclock + f_agTw + (Network.Riak.Protocol.BucketProps.BucketProps x_agTx + x_agTy + x_agTz + x_agTA + x_agTB + x_agTC + x_agTD + x_agTE + x_agTF + x_agTG + x_agTH + x_agTI + x_agTJ + x_agTK + x_agTL + x_agTM + x_agTN + x_agTO + x_agTP + x_agTQ + x_agTR + x_agTS + x_agTT + x_agTU + x_agTV + x_agTW + x_agTX + x_agTY) + = fmap + (\ y_agTZ + -> Network.Riak.Protocol.BucketProps.BucketProps + x_agTx + x_agTy + x_agTz + x_agTA + x_agTB + x_agTC + x_agTD + x_agTE + x_agTF + x_agTG + y_agTZ + x_agTI + x_agTJ + x_agTK + x_agTL + x_agTM + x_agTN + x_agTO + x_agTP + x_agTQ + x_agTR + x_agTS + x_agTT + x_agTU + x_agTV + x_agTW + x_agTX + x_agTY) + (f_agTw x_agTH) +class HasModfun s a | s -> a where + modfun :: Lens' s a +instance HasModfun Network.Riak.Protocol.CommitHook.CommitHook (Maybe Network.Riak.Protocol.ModFun.ModFun) where + {-# INLINE modfun #-} + modfun f_ahcb (Network.Riak.Protocol.CommitHook.CommitHook x_ahcc x_ahcd) + = fmap (\ y_ahce -> Network.Riak.Protocol.CommitHook.CommitHook y_ahce x_ahcd) (f_ahcb x_ahcc) +class HasName s a | s -> a where + name :: Lens' s a +instance HasName Network.Riak.Protocol.CommitHook.CommitHook (Maybe ByteString) where + {-# INLINE name #-} + name f_ahcf (Network.Riak.Protocol.CommitHook.CommitHook x_ahcg x_ahch) + = fmap (\ y_ahci -> Network.Riak.Protocol.CommitHook.CommitHook x_ahcg y_ahci) (f_ahcf x_ahch) +class HasCharset s a | s -> a where + charset :: Lens' s a +instance HasCharset Network.Riak.Protocol.Content.Content (Maybe ByteString) where + {-# INLINE charset #-} + charset f_ahdI (Network.Riak.Protocol.Content.Content x_ahdJ x_ahdK x_ahdL x_ahdM x_ahdN x_ahdO x_ahdP x_ahdQ x_ahdR x_ahdS x_ahdT) + = fmap + (\ y_ahdU -> Network.Riak.Protocol.Content.Content x_ahdJ x_ahdK y_ahdU x_ahdM x_ahdN x_ahdO x_ahdP x_ahdQ x_ahdR x_ahdS x_ahdT) + (f_ahdI x_ahdL) +class HasContentEncoding s a | s -> a where + content_encoding :: Lens' s a +instance HasContentEncoding Network.Riak.Protocol.Content.Content (Maybe ByteString) where + {-# INLINE content_encoding #-} + content_encoding + f_ahdV + (Network.Riak.Protocol.Content.Content x_ahdW x_ahdX x_ahdY x_ahdZ x_ahe0 x_ahe1 x_ahe2 x_ahe3 x_ahe4 x_ahe5 x_ahe6) + = fmap + (\ y_ahe7 -> Network.Riak.Protocol.Content.Content x_ahdW x_ahdX x_ahdY y_ahe7 x_ahe0 x_ahe1 x_ahe2 x_ahe3 x_ahe4 x_ahe5 x_ahe6) + (f_ahdV x_ahdZ) +class HasContentType s a | s -> a where + content_type :: Lens' s a +instance HasContentType Network.Riak.Protocol.Content.Content (Maybe ByteString) where + {-# INLINE content_type #-} + content_type + f_ahe8 + (Network.Riak.Protocol.Content.Content x_ahe9 x_ahea x_aheb x_ahec x_ahed x_ahee x_ahef x_aheg x_aheh x_ahei x_ahej) + = fmap + (\ y_ahek -> Network.Riak.Protocol.Content.Content x_ahe9 y_ahek x_aheb x_ahec x_ahed x_ahee x_ahef x_aheg x_aheh x_ahei x_ahej) + (f_ahe8 x_ahea) +class HasDeleted s a | s -> a where + deleted :: Lens' s a +instance HasDeleted Network.Riak.Protocol.Content.Content (Maybe Bool) where + {-# INLINE deleted #-} + deleted f_ahel (Network.Riak.Protocol.Content.Content x_ahem x_ahen x_aheo x_ahep x_aheq x_aher x_ahes x_ahet x_aheu x_ahev x_ahew) + = fmap + (\ y_ahex -> Network.Riak.Protocol.Content.Content x_ahem x_ahen x_aheo x_ahep x_aheq x_aher x_ahes x_ahet x_aheu x_ahev y_ahex) + (f_ahel x_ahew) +class HasIndexes s a | s -> a where + indexes :: Lens' s a +instance HasIndexes Network.Riak.Protocol.Content.Content (Seq Network.Riak.Protocol.Pair.Pair) where + {-# INLINE indexes #-} + indexes f_ahey (Network.Riak.Protocol.Content.Content x_ahez x_aheA x_aheB x_aheC x_aheD x_aheE x_aheF x_aheG x_aheH x_aheI x_aheJ) + = fmap + (\ y_aheK -> Network.Riak.Protocol.Content.Content x_ahez x_aheA x_aheB x_aheC x_aheD x_aheE x_aheF x_aheG x_aheH y_aheK x_aheJ) + (f_ahey x_aheI) +class HasLastMod s a | s -> a where + last_mod :: Lens' s a +instance HasLastMod Network.Riak.Protocol.Content.Content (Maybe Word32) where + {-# INLINE last_mod #-} + last_mod f_aheL (Network.Riak.Protocol.Content.Content x_aheM x_aheN x_aheO x_aheP x_aheQ x_aheR x_aheS x_aheT x_aheU x_aheV x_aheW) + = fmap + (\ y_aheX -> Network.Riak.Protocol.Content.Content x_aheM x_aheN x_aheO x_aheP x_aheQ x_aheR y_aheX x_aheT x_aheU x_aheV x_aheW) + (f_aheL x_aheS) +class HasLastModUsecs s a | s -> a where + last_mod_usecs :: Lens' s a +instance HasLastModUsecs Network.Riak.Protocol.Content.Content (Maybe Word32) where + {-# INLINE last_mod_usecs #-} + last_mod_usecs + f_aheY + (Network.Riak.Protocol.Content.Content x_aheZ x_ahf0 x_ahf1 x_ahf2 x_ahf3 x_ahf4 x_ahf5 x_ahf6 x_ahf7 x_ahf8 x_ahf9) + = fmap + (\ y_ahfa -> Network.Riak.Protocol.Content.Content x_aheZ x_ahf0 x_ahf1 x_ahf2 x_ahf3 x_ahf4 x_ahf5 y_ahfa x_ahf7 x_ahf8 x_ahf9) + (f_aheY x_ahf6) +class HasLinks s a | s -> a where + links :: Lens' s a +instance HasLinks Network.Riak.Protocol.Content.Content (Seq Network.Riak.Protocol.Link.Link) where + {-# INLINE links #-} + links f_ahfb (Network.Riak.Protocol.Content.Content x_ahfc x_ahfd x_ahfe x_ahff x_ahfg x_ahfh x_ahfi x_ahfj x_ahfk x_ahfl x_ahfm) + = fmap + (\ y_ahfn -> Network.Riak.Protocol.Content.Content x_ahfc x_ahfd x_ahfe x_ahff x_ahfg y_ahfn x_ahfi x_ahfj x_ahfk x_ahfl x_ahfm) + (f_ahfb x_ahfh) +class HasUsermeta s a | s -> a where + usermeta :: Lens' s a +instance HasUsermeta Network.Riak.Protocol.Content.Content (Seq Network.Riak.Protocol.Pair.Pair) where + {-# INLINE usermeta #-} + usermeta f_ahfo (Network.Riak.Protocol.Content.Content x_ahfp x_ahfq x_ahfr x_ahfs x_ahft x_ahfu x_ahfv x_ahfw x_ahfx x_ahfy x_ahfz) + = fmap + (\ y_ahfA -> Network.Riak.Protocol.Content.Content x_ahfp x_ahfq x_ahfr x_ahfs x_ahft x_ahfu x_ahfv x_ahfw y_ahfA x_ahfy x_ahfz) + (f_ahfo x_ahfx) +class HasValue s a | s -> a where + value :: Lens' s a +instance HasValue Network.Riak.Protocol.Content.Content ByteString where + {-# INLINE value #-} + value f_ahfB (Network.Riak.Protocol.Content.Content x_ahfC x_ahfD x_ahfE x_ahfF x_ahfG x_ahfH x_ahfI x_ahfJ x_ahfK x_ahfL x_ahfM) + = fmap + (\ y_ahfN -> Network.Riak.Protocol.Content.Content y_ahfN x_ahfD x_ahfE x_ahfF x_ahfG x_ahfH x_ahfI x_ahfJ x_ahfK x_ahfL x_ahfM) + (f_ahfB x_ahfC) +class HasVtag s a | s -> a where + vtag :: Lens' s a +instance HasVtag Network.Riak.Protocol.Content.Content (Maybe ByteString) where + {-# INLINE vtag #-} + vtag f_ahfO (Network.Riak.Protocol.Content.Content x_ahfP x_ahfQ x_ahfR x_ahfS x_ahfT x_ahfU x_ahfV x_ahfW x_ahfX x_ahfY x_ahfZ) + = fmap + (\ y_ahg0 -> Network.Riak.Protocol.Content.Content x_ahfP x_ahfQ x_ahfR x_ahfS y_ahg0 x_ahfU x_ahfV x_ahfW x_ahfX x_ahfY x_ahfZ) + (f_ahfO x_ahfT) +instance HasBasicQuorum Network.Riak.Protocol.CounterGetRequest.CounterGetRequest (Maybe Bool) where + {-# INLINE basic_quorum #-} + basic_quorum f_ahne (Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnf x_ahng x_ahnh x_ahni x_ahnj x_ahnk) + = fmap + (\ y_ahnl -> Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnf x_ahng x_ahnh x_ahni y_ahnl x_ahnk) (f_ahne x_ahnj) +class HasBucket s a | s -> a where + bucket :: Lens' s a +instance HasBucket Network.Riak.Protocol.CounterGetRequest.CounterGetRequest ByteString where + {-# INLINE bucket #-} + bucket f_ahnm (Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnn x_ahno x_ahnp x_ahnq x_ahnr x_ahns) + = fmap + (\ y_ahnt -> Network.Riak.Protocol.CounterGetRequest.CounterGetRequest y_ahnt x_ahno x_ahnp x_ahnq x_ahnr x_ahns) (f_ahnm x_ahnn) +class HasKey s a | s -> a where + key :: Lens' s a +instance HasKey Network.Riak.Protocol.CounterGetRequest.CounterGetRequest ByteString where + {-# INLINE key #-} + key f_ahnu (Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnv x_ahnw x_ahnx x_ahny x_ahnz x_ahnA) + = fmap + (\ y_ahnB -> Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnv y_ahnB x_ahnx x_ahny x_ahnz x_ahnA) (f_ahnu x_ahnw) +instance HasNotfoundOk Network.Riak.Protocol.CounterGetRequest.CounterGetRequest (Maybe Bool) where + {-# INLINE notfound_ok #-} + notfound_ok f_ahnC (Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnD x_ahnE x_ahnF x_ahnG x_ahnH x_ahnI) + = fmap + (\ y_ahnJ -> Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnD x_ahnE x_ahnF x_ahnG x_ahnH y_ahnJ) (f_ahnC x_ahnI) +instance HasPr Network.Riak.Protocol.CounterGetRequest.CounterGetRequest (Maybe Word32) where + {-# INLINE pr #-} + pr f_ahnK (Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnL x_ahnM x_ahnN x_ahnO x_ahnP x_ahnQ) + = fmap + (\ y_ahnR -> Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnL x_ahnM x_ahnN y_ahnR x_ahnP x_ahnQ) (f_ahnK x_ahnO) +instance HasR Network.Riak.Protocol.CounterGetRequest.CounterGetRequest (Maybe Word32) where + {-# INLINE r #-} + r f_ahnS (Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnT x_ahnU x_ahnV x_ahnW x_ahnX x_ahnY) + = fmap + (\ y_ahnZ -> Network.Riak.Protocol.CounterGetRequest.CounterGetRequest x_ahnT x_ahnU y_ahnZ x_ahnW x_ahnX x_ahnY) (f_ahnS x_ahnV) +instance HasValue Network.Riak.Protocol.CounterGetResponse.CounterGetResponse (Maybe Int64) where + {-# INLINE value #-} + value f_ahqj (Network.Riak.Protocol.CounterGetResponse.CounterGetResponse x_ahqk) + = fmap (\ y_ahql -> Network.Riak.Protocol.CounterGetResponse.CounterGetResponse y_ahql) (f_ahqj x_ahqk) +class HasIncrement s a | s -> a where + increment :: Lens' s a +instance HasIncrement Network.Riak.Protocol.CounterOp.CounterOp (Maybe Int64) where + {-# INLINE increment #-} + increment f_ahqH (Network.Riak.Protocol.CounterOp.CounterOp x_ahqI) + = fmap (\ y_ahqJ -> Network.Riak.Protocol.CounterOp.CounterOp y_ahqJ) (f_ahqH x_ahqI) +class HasAmount s a | s -> a where + amount :: Lens' s a +instance HasAmount Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest Int64 where + {-# INLINE amount #-} + amount f_ahrv (Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahrw x_ahrx x_ahry x_ahrz x_ahrA x_ahrB x_ahrC) + = fmap + (\ y_ahrD -> Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahrw x_ahrx y_ahrD x_ahrz x_ahrA x_ahrB x_ahrC) + (f_ahrv x_ahry) +instance HasBucket Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest ByteString where + {-# INLINE bucket #-} + bucket f_ahrE (Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahrF x_ahrG x_ahrH x_ahrI x_ahrJ x_ahrK x_ahrL) + = fmap + (\ y_ahrM -> Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest y_ahrM x_ahrG x_ahrH x_ahrI x_ahrJ x_ahrK x_ahrL) + (f_ahrE x_ahrF) +instance HasDw Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest (Maybe Word32) where + {-# INLINE dw #-} + dw f_ahrN (Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahrO x_ahrP x_ahrQ x_ahrR x_ahrS x_ahrT x_ahrU) + = fmap + (\ y_ahrV -> Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahrO x_ahrP x_ahrQ x_ahrR y_ahrV x_ahrT x_ahrU) + (f_ahrN x_ahrS) +instance HasKey Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest ByteString where + {-# INLINE key #-} + key f_ahrW (Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahrX x_ahrY x_ahrZ x_ahs0 x_ahs1 x_ahs2 x_ahs3) + = fmap + (\ y_ahs4 -> Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahrX y_ahs4 x_ahrZ x_ahs0 x_ahs1 x_ahs2 x_ahs3) + (f_ahrW x_ahrY) +instance HasPw Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest (Maybe Word32) where + {-# INLINE pw #-} + pw f_ahs5 (Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahs6 x_ahs7 x_ahs8 x_ahs9 x_ahsa x_ahsb x_ahsc) + = fmap + (\ y_ahsd -> Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahs6 x_ahs7 x_ahs8 x_ahs9 x_ahsa y_ahsd x_ahsc) + (f_ahs5 x_ahsb) +class HasReturnvalue s a | s -> a where + returnvalue :: Lens' s a +instance HasReturnvalue Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest (Maybe Bool) where + {-# INLINE returnvalue #-} + returnvalue f_ahse (Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahsf x_ahsg x_ahsh x_ahsi x_ahsj x_ahsk x_ahsl) + = fmap + (\ y_ahsm -> Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahsf x_ahsg x_ahsh x_ahsi x_ahsj x_ahsk y_ahsm) + (f_ahse x_ahsl) +instance HasW Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest (Maybe Word32) where + {-# INLINE w #-} + w f_ahsn (Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahso x_ahsp x_ahsq x_ahsr x_ahss x_ahst x_ahsu) + = fmap + (\ y_ahsv -> Network.Riak.Protocol.CounterUpdateRequest.CounterUpdateRequest x_ahso x_ahsp x_ahsq y_ahsv x_ahss x_ahst x_ahsu) + (f_ahsn x_ahsr) +instance HasValue Network.Riak.Protocol.CounterUpdateResponse.CounterUpdateResponse (Maybe Int64) where + {-# INLINE value #-} + value f_ahv4 (Network.Riak.Protocol.CounterUpdateResponse.CounterUpdateResponse x_ahv5) + = fmap (\ y_ahv6 -> Network.Riak.Protocol.CounterUpdateResponse.CounterUpdateResponse y_ahv6) (f_ahv4 x_ahv5) +instance HasBucket Network.Riak.Protocol.CSBucketRequest.CSBucketRequest ByteString where + {-# INLINE bucket #-} + bucket f_ahvs (Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahvt x_ahvu x_ahvv x_ahvw x_ahvx x_ahvy x_ahvz x_ahvA x_ahvB) + = fmap + (\ y_ahvC -> Network.Riak.Protocol.CSBucketRequest.CSBucketRequest y_ahvC x_ahvu x_ahvv x_ahvw x_ahvx x_ahvy x_ahvz x_ahvA x_ahvB) + (f_ahvs x_ahvt) +class HasContinuation s a | s -> a where + continuation :: Lens' s a +instance HasContinuation Network.Riak.Protocol.CSBucketRequest.CSBucketRequest (Maybe ByteString) where + {-# INLINE continuation #-} + continuation + f_ahvD + (Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahvE x_ahvF x_ahvG x_ahvH x_ahvI x_ahvJ x_ahvK x_ahvL x_ahvM) + = fmap + (\ y_ahvN -> Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahvE x_ahvF x_ahvG x_ahvH x_ahvI y_ahvN x_ahvK x_ahvL x_ahvM) + (f_ahvD x_ahvJ) +class HasEndIncl s a | s -> a where + end_incl :: Lens' s a +instance HasEndIncl Network.Riak.Protocol.CSBucketRequest.CSBucketRequest (Maybe Bool) where + {-# INLINE end_incl #-} + end_incl + f_ahvO + (Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahvP x_ahvQ x_ahvR x_ahvS x_ahvT x_ahvU x_ahvV x_ahvW x_ahvX) + = fmap + (\ y_ahvY -> Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahvP x_ahvQ x_ahvR x_ahvS y_ahvY x_ahvU x_ahvV x_ahvW x_ahvX) + (f_ahvO x_ahvT) +class HasEndKey s a | s -> a where + end_key :: Lens' s a +instance HasEndKey Network.Riak.Protocol.CSBucketRequest.CSBucketRequest (Maybe ByteString) where + {-# INLINE end_key #-} + end_key f_ahvZ (Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahw0 x_ahw1 x_ahw2 x_ahw3 x_ahw4 x_ahw5 x_ahw6 x_ahw7 x_ahw8) + = fmap + (\ y_ahw9 -> Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahw0 x_ahw1 y_ahw9 x_ahw3 x_ahw4 x_ahw5 x_ahw6 x_ahw7 x_ahw8) + (f_ahvZ x_ahw2) +class HasMaxResults s a | s -> a where + max_results :: Lens' s a +instance HasMaxResults Network.Riak.Protocol.CSBucketRequest.CSBucketRequest (Maybe Word32) where + {-# INLINE max_results #-} + max_results + f_ahwa + (Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwb x_ahwc x_ahwd x_ahwe x_ahwf x_ahwg x_ahwh x_ahwi x_ahwj) + = fmap + (\ y_ahwk -> Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwb x_ahwc x_ahwd x_ahwe x_ahwf x_ahwg y_ahwk x_ahwi x_ahwj) + (f_ahwa x_ahwh) +class HasStartIncl s a | s -> a where + start_incl :: Lens' s a +instance HasStartIncl Network.Riak.Protocol.CSBucketRequest.CSBucketRequest (Maybe Bool) where + {-# INLINE start_incl #-} + start_incl + f_ahwl + (Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwm x_ahwn x_ahwo x_ahwp x_ahwq x_ahwr x_ahws x_ahwt x_ahwu) + = fmap + (\ y_ahwv -> Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwm x_ahwn x_ahwo y_ahwv x_ahwq x_ahwr x_ahws x_ahwt x_ahwu) + (f_ahwl x_ahwp) +class HasStartKey s a | s -> a where + start_key :: Lens' s a +instance HasStartKey Network.Riak.Protocol.CSBucketRequest.CSBucketRequest ByteString where + {-# INLINE start_key #-} + start_key + f_ahww + (Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwx x_ahwy x_ahwz x_ahwA x_ahwB x_ahwC x_ahwD x_ahwE x_ahwF) + = fmap + (\ y_ahwG -> Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwx y_ahwG x_ahwz x_ahwA x_ahwB x_ahwC x_ahwD x_ahwE x_ahwF) + (f_ahww x_ahwy) +class HasTimeout s a | s -> a where + timeout :: Lens' s a +instance HasTimeout Network.Riak.Protocol.CSBucketRequest.CSBucketRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout f_ahwH (Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwI x_ahwJ x_ahwK x_ahwL x_ahwM x_ahwN x_ahwO x_ahwP x_ahwQ) + = fmap + (\ y_ahwR -> Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwI x_ahwJ x_ahwK x_ahwL x_ahwM x_ahwN x_ahwO y_ahwR x_ahwQ) + (f_ahwH x_ahwP) +class HasType' s a | s -> a where + type' :: Lens' s a +instance HasType' Network.Riak.Protocol.CSBucketRequest.CSBucketRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' f_ahwS (Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwT x_ahwU x_ahwV x_ahwW x_ahwX x_ahwY x_ahwZ x_ahx0 x_ahx1) + = fmap + (\ y_ahx2 -> Network.Riak.Protocol.CSBucketRequest.CSBucketRequest x_ahwT x_ahwU x_ahwV x_ahwW x_ahwX x_ahwY x_ahwZ x_ahx0 y_ahx2) + (f_ahwS x_ahx1) +instance HasContinuation Network.Riak.Protocol.CSBucketResponse.CSBucketResponse (Maybe ByteString) where + {-# INLINE continuation #-} + continuation f_ahCy (Network.Riak.Protocol.CSBucketResponse.CSBucketResponse x_ahCz x_ahCA x_ahCB) + = fmap (\ y_ahCC -> Network.Riak.Protocol.CSBucketResponse.CSBucketResponse x_ahCz y_ahCC x_ahCB) (f_ahCy x_ahCA) +class HasDone s a | s -> a where + done :: Lens' s a +instance HasDone Network.Riak.Protocol.CSBucketResponse.CSBucketResponse (Maybe Bool) where + {-# INLINE done #-} + done f_ahCD (Network.Riak.Protocol.CSBucketResponse.CSBucketResponse x_ahCE x_ahCF x_ahCG) + = fmap (\ y_ahCH -> Network.Riak.Protocol.CSBucketResponse.CSBucketResponse x_ahCE x_ahCF y_ahCH) (f_ahCD x_ahCG) +class HasObjects s a | s -> a where + objects :: Lens' s a +instance HasObjects Network.Riak.Protocol.CSBucketResponse.CSBucketResponse (Seq Network.Riak.Protocol.IndexObject.IndexObject) where + {-# INLINE objects #-} + objects f_ahCI (Network.Riak.Protocol.CSBucketResponse.CSBucketResponse x_ahCJ x_ahCK x_ahCL) + = fmap (\ y_ahCM -> Network.Riak.Protocol.CSBucketResponse.CSBucketResponse y_ahCM x_ahCK x_ahCL) (f_ahCI x_ahCJ) +instance HasBucket Network.Riak.Protocol.DeleteRequest.DeleteRequest ByteString where + {-# INLINE bucket #-} + bucket + f_ahEq + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahEr + x_ahEs + x_ahEt + x_ahEu + x_ahEv + x_ahEw + x_ahEx + x_ahEy + x_ahEz + x_ahEA + x_ahEB + x_ahEC + x_ahED) + = fmap + (\ y_ahEE + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + y_ahEE x_ahEs x_ahEt x_ahEu x_ahEv x_ahEw x_ahEx x_ahEy x_ahEz x_ahEA x_ahEB x_ahEC x_ahED) + (f_ahEq x_ahEr) +instance HasDw Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe Word32) where + {-# INLINE dw #-} + dw + f_ahEF + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahEG + x_ahEH + x_ahEI + x_ahEJ + x_ahEK + x_ahEL + x_ahEM + x_ahEN + x_ahEO + x_ahEP + x_ahEQ + x_ahER + x_ahES) + = fmap + (\ y_ahET + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahEG x_ahEH x_ahEI x_ahEJ x_ahEK x_ahEL x_ahEM x_ahEN y_ahET x_ahEP x_ahEQ x_ahER x_ahES) + (f_ahEF x_ahEO) +instance HasKey Network.Riak.Protocol.DeleteRequest.DeleteRequest ByteString where + {-# INLINE key #-} + key + f_ahEU + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahEV + x_ahEW + x_ahEX + x_ahEY + x_ahEZ + x_ahF0 + x_ahF1 + x_ahF2 + x_ahF3 + x_ahF4 + x_ahF5 + x_ahF6 + x_ahF7) + = fmap + (\ y_ahF8 + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahEV y_ahF8 x_ahEX x_ahEY x_ahEZ x_ahF0 x_ahF1 x_ahF2 x_ahF3 x_ahF4 x_ahF5 x_ahF6 x_ahF7) + (f_ahEU x_ahEW) +instance HasNVal Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe Word32) where + {-# INLINE n_val #-} + n_val + f_ahF9 + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahFa + x_ahFb + x_ahFc + x_ahFd + x_ahFe + x_ahFf + x_ahFg + x_ahFh + x_ahFi + x_ahFj + x_ahFk + x_ahFl + x_ahFm) + = fmap + (\ y_ahFn + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahFa x_ahFb x_ahFc x_ahFd x_ahFe x_ahFf x_ahFg x_ahFh x_ahFi x_ahFj x_ahFk y_ahFn x_ahFm) + (f_ahF9 x_ahFl) +instance HasPr Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe Word32) where + {-# INLINE pr #-} + pr + f_ahFo + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahFp + x_ahFq + x_ahFr + x_ahFs + x_ahFt + x_ahFu + x_ahFv + x_ahFw + x_ahFx + x_ahFy + x_ahFz + x_ahFA + x_ahFB) + = fmap + (\ y_ahFC + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahFp x_ahFq x_ahFr x_ahFs x_ahFt x_ahFu y_ahFC x_ahFw x_ahFx x_ahFy x_ahFz x_ahFA x_ahFB) + (f_ahFo x_ahFv) +instance HasPw Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe Word32) where + {-# INLINE pw #-} + pw + f_ahFD + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahFE + x_ahFF + x_ahFG + x_ahFH + x_ahFI + x_ahFJ + x_ahFK + x_ahFL + x_ahFM + x_ahFN + x_ahFO + x_ahFP + x_ahFQ) + = fmap + (\ y_ahFR + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahFE x_ahFF x_ahFG x_ahFH x_ahFI x_ahFJ x_ahFK y_ahFR x_ahFM x_ahFN x_ahFO x_ahFP x_ahFQ) + (f_ahFD x_ahFL) +instance HasR Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe Word32) where + {-# INLINE r #-} + r f_ahFS + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahFT + x_ahFU + x_ahFV + x_ahFW + x_ahFX + x_ahFY + x_ahFZ + x_ahG0 + x_ahG1 + x_ahG2 + x_ahG3 + x_ahG4 + x_ahG5) + = fmap + (\ y_ahG6 + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahFT x_ahFU x_ahFV x_ahFW y_ahG6 x_ahFY x_ahFZ x_ahG0 x_ahG1 x_ahG2 x_ahG3 x_ahG4 x_ahG5) + (f_ahFS x_ahFX) +instance HasRw Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe Word32) where + {-# INLINE rw #-} + rw + f_ahG7 + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahG8 + x_ahG9 + x_ahGa + x_ahGb + x_ahGc + x_ahGd + x_ahGe + x_ahGf + x_ahGg + x_ahGh + x_ahGi + x_ahGj + x_ahGk) + = fmap + (\ y_ahGl + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahG8 x_ahG9 y_ahGl x_ahGb x_ahGc x_ahGd x_ahGe x_ahGf x_ahGg x_ahGh x_ahGi x_ahGj x_ahGk) + (f_ahG7 x_ahGa) +class HasSloppyQuorum s a | s -> a where + sloppy_quorum :: Lens' s a +instance HasSloppyQuorum Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe Bool) where + {-# INLINE sloppy_quorum #-} + sloppy_quorum + f_ahGm + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahGn + x_ahGo + x_ahGp + x_ahGq + x_ahGr + x_ahGs + x_ahGt + x_ahGu + x_ahGv + x_ahGw + x_ahGx + x_ahGy + x_ahGz) + = fmap + (\ y_ahGA + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahGn x_ahGo x_ahGp x_ahGq x_ahGr x_ahGs x_ahGt x_ahGu x_ahGv x_ahGw y_ahGA x_ahGy x_ahGz) + (f_ahGm x_ahGx) +instance HasTimeout Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout + f_ahGB + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahGC + x_ahGD + x_ahGE + x_ahGF + x_ahGG + x_ahGH + x_ahGI + x_ahGJ + x_ahGK + x_ahGL + x_ahGM + x_ahGN + x_ahGO) + = fmap + (\ y_ahGP + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahGC x_ahGD x_ahGE x_ahGF x_ahGG x_ahGH x_ahGI x_ahGJ x_ahGK y_ahGP x_ahGM x_ahGN x_ahGO) + (f_ahGB x_ahGL) +instance HasType' Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' + f_ahGQ + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahGR + x_ahGS + x_ahGT + x_ahGU + x_ahGV + x_ahGW + x_ahGX + x_ahGY + x_ahGZ + x_ahH0 + x_ahH1 + x_ahH2 + x_ahH3) + = fmap + (\ y_ahH4 + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahGR x_ahGS x_ahGT x_ahGU x_ahGV x_ahGW x_ahGX x_ahGY x_ahGZ x_ahH0 x_ahH1 x_ahH2 y_ahH4) + (f_ahGQ x_ahH3) +class HasVclock s a | s -> a where + vclock :: Lens' s a +instance HasVclock Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe ByteString) where + {-# INLINE vclock #-} + vclock + f_ahH5 + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahH6 + x_ahH7 + x_ahH8 + x_ahH9 + x_ahHa + x_ahHb + x_ahHc + x_ahHd + x_ahHe + x_ahHf + x_ahHg + x_ahHh + x_ahHi) + = fmap + (\ y_ahHj + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahH6 x_ahH7 x_ahH8 y_ahHj x_ahHa x_ahHb x_ahHc x_ahHd x_ahHe x_ahHf x_ahHg x_ahHh x_ahHi) + (f_ahH5 x_ahH9) +instance HasW Network.Riak.Protocol.DeleteRequest.DeleteRequest (Maybe Word32) where + {-# INLINE w #-} + w f_ahHk + (Network.Riak.Protocol.DeleteRequest.DeleteRequest x_ahHl + x_ahHm + x_ahHn + x_ahHo + x_ahHp + x_ahHq + x_ahHr + x_ahHs + x_ahHt + x_ahHu + x_ahHv + x_ahHw + x_ahHx) + = fmap + (\ y_ahHy + -> Network.Riak.Protocol.DeleteRequest.DeleteRequest + x_ahHl x_ahHm x_ahHn x_ahHo x_ahHp y_ahHy x_ahHr x_ahHs x_ahHt x_ahHu x_ahHv x_ahHw x_ahHx) + (f_ahHk x_ahHq) +instance HasBasicQuorum Network.Riak.Protocol.DtFetchRequest.DtFetchRequest (Maybe Bool) where + {-# INLINE basic_quorum #-} + basic_quorum + f_ahLs + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahLt x_ahLu x_ahLv x_ahLw x_ahLx x_ahLy x_ahLz x_ahLA x_ahLB x_ahLC x_ahLD) + = fmap + (\ y_ahLE + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahLt x_ahLu x_ahLv x_ahLw x_ahLx y_ahLE x_ahLz x_ahLA x_ahLB x_ahLC x_ahLD) + (f_ahLs x_ahLy) +instance HasBucket Network.Riak.Protocol.DtFetchRequest.DtFetchRequest ByteString where + {-# INLINE bucket #-} + bucket + f_ahLF + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahLG x_ahLH x_ahLI x_ahLJ x_ahLK x_ahLL x_ahLM x_ahLN x_ahLO x_ahLP x_ahLQ) + = fmap + (\ y_ahLR + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest y_ahLR x_ahLH x_ahLI x_ahLJ x_ahLK x_ahLL x_ahLM x_ahLN x_ahLO x_ahLP x_ahLQ) + (f_ahLF x_ahLG) +class HasIncludeContext s a | s -> a where + include_context :: Lens' s a +instance HasIncludeContext Network.Riak.Protocol.DtFetchRequest.DtFetchRequest (Maybe Bool) where + {-# INLINE include_context #-} + include_context + f_ahLS + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahLT x_ahLU x_ahLV x_ahLW x_ahLX x_ahLY x_ahLZ x_ahM0 x_ahM1 x_ahM2 x_ahM3) + = fmap + (\ y_ahM4 + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahLT x_ahLU x_ahLV x_ahLW x_ahLX x_ahLY x_ahLZ x_ahM0 x_ahM1 x_ahM2 y_ahM4) + (f_ahLS x_ahM3) +instance HasKey Network.Riak.Protocol.DtFetchRequest.DtFetchRequest ByteString where + {-# INLINE key #-} + key + f_ahM5 + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahM6 x_ahM7 x_ahM8 x_ahM9 x_ahMa x_ahMb x_ahMc x_ahMd x_ahMe x_ahMf x_ahMg) + = fmap + (\ y_ahMh + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahM6 y_ahMh x_ahM8 x_ahM9 x_ahMa x_ahMb x_ahMc x_ahMd x_ahMe x_ahMf x_ahMg) + (f_ahM5 x_ahM7) +instance HasNVal Network.Riak.Protocol.DtFetchRequest.DtFetchRequest (Maybe Word32) where + {-# INLINE n_val #-} + n_val + f_ahMi + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahMj x_ahMk x_ahMl x_ahMm x_ahMn x_ahMo x_ahMp x_ahMq x_ahMr x_ahMs x_ahMt) + = fmap + (\ y_ahMu + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahMj x_ahMk x_ahMl x_ahMm x_ahMn x_ahMo x_ahMp x_ahMq x_ahMr y_ahMu x_ahMt) + (f_ahMi x_ahMs) +instance HasNotfoundOk Network.Riak.Protocol.DtFetchRequest.DtFetchRequest (Maybe Bool) where + {-# INLINE notfound_ok #-} + notfound_ok + f_ahMv + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahMw x_ahMx x_ahMy x_ahMz x_ahMA x_ahMB x_ahMC x_ahMD x_ahME x_ahMF x_ahMG) + = fmap + (\ y_ahMH + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahMw x_ahMx x_ahMy x_ahMz x_ahMA x_ahMB y_ahMH x_ahMD x_ahME x_ahMF x_ahMG) + (f_ahMv x_ahMC) +instance HasPr Network.Riak.Protocol.DtFetchRequest.DtFetchRequest (Maybe Word32) where + {-# INLINE pr #-} + pr + f_ahMI + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahMJ x_ahMK x_ahML x_ahMM x_ahMN x_ahMO x_ahMP x_ahMQ x_ahMR x_ahMS x_ahMT) + = fmap + (\ y_ahMU + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahMJ x_ahMK x_ahML x_ahMM y_ahMU x_ahMO x_ahMP x_ahMQ x_ahMR x_ahMS x_ahMT) + (f_ahMI x_ahMN) +instance HasR Network.Riak.Protocol.DtFetchRequest.DtFetchRequest (Maybe Word32) where + {-# INLINE r #-} + r f_ahMV + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahMW x_ahMX x_ahMY x_ahMZ x_ahN0 x_ahN1 x_ahN2 x_ahN3 x_ahN4 x_ahN5 x_ahN6) + = fmap + (\ y_ahN7 + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahMW x_ahMX x_ahMY y_ahN7 x_ahN0 x_ahN1 x_ahN2 x_ahN3 x_ahN4 x_ahN5 x_ahN6) + (f_ahMV x_ahMZ) +instance HasSloppyQuorum Network.Riak.Protocol.DtFetchRequest.DtFetchRequest (Maybe Bool) where + {-# INLINE sloppy_quorum #-} + sloppy_quorum + f_ahN8 + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahN9 x_ahNa x_ahNb x_ahNc x_ahNd x_ahNe x_ahNf x_ahNg x_ahNh x_ahNi x_ahNj) + = fmap + (\ y_ahNk + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahN9 x_ahNa x_ahNb x_ahNc x_ahNd x_ahNe x_ahNf x_ahNg y_ahNk x_ahNi x_ahNj) + (f_ahN8 x_ahNh) +instance HasTimeout Network.Riak.Protocol.DtFetchRequest.DtFetchRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout + f_ahNl + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahNm x_ahNn x_ahNo x_ahNp x_ahNq x_ahNr x_ahNs x_ahNt x_ahNu x_ahNv x_ahNw) + = fmap + (\ y_ahNx + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahNm x_ahNn x_ahNo x_ahNp x_ahNq x_ahNr x_ahNs y_ahNx x_ahNu x_ahNv x_ahNw) + (f_ahNl x_ahNt) +instance HasType' Network.Riak.Protocol.DtFetchRequest.DtFetchRequest ByteString where + {-# INLINE type' #-} + type' + f_ahNy + (Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahNz x_ahNA x_ahNB x_ahNC x_ahND x_ahNE x_ahNF x_ahNG x_ahNH x_ahNI x_ahNJ) + = fmap + (\ y_ahNK + -> Network.Riak.Protocol.DtFetchRequest.DtFetchRequest x_ahNz x_ahNA y_ahNK x_ahNC x_ahND x_ahNE x_ahNF x_ahNG x_ahNH x_ahNI x_ahNJ) + (f_ahNy x_ahNB) +class HasContext s a | s -> a where + context :: Lens' s a +instance HasContext Network.Riak.Protocol.DtFetchResponse.DtFetchResponse (Maybe ByteString) where + {-# INLINE context #-} + context f_ahQM (Network.Riak.Protocol.DtFetchResponse.DtFetchResponse x_ahQN x_ahQO x_ahQP) + = fmap (\ y_ahQQ -> Network.Riak.Protocol.DtFetchResponse.DtFetchResponse y_ahQQ x_ahQO x_ahQP) (f_ahQM x_ahQN) +instance HasType' Network.Riak.Protocol.DtFetchResponse.DtFetchResponse Network.Riak.Protocol.DtFetchResponse.DataType.DataType where + {-# INLINE type' #-} + type' f_ahQR (Network.Riak.Protocol.DtFetchResponse.DtFetchResponse x_ahQS x_ahQT x_ahQU) + = fmap (\ y_ahQV -> Network.Riak.Protocol.DtFetchResponse.DtFetchResponse x_ahQS y_ahQV x_ahQU) (f_ahQR x_ahQT) +instance HasValue Network.Riak.Protocol.DtFetchResponse.DtFetchResponse (Maybe Network.Riak.Protocol.DtValue.DtValue) where + {-# INLINE value #-} + value f_ahQW (Network.Riak.Protocol.DtFetchResponse.DtFetchResponse x_ahQX x_ahQY x_ahQZ) + = fmap (\ y_ahR0 -> Network.Riak.Protocol.DtFetchResponse.DtFetchResponse x_ahQX x_ahQY y_ahR0) (f_ahQW x_ahQZ) +class HasCounterOp s a | s -> a where + counter_op :: Lens' s a +instance HasCounterOp Network.Riak.Protocol.DtOp.DtOp (Maybe Network.Riak.Protocol.CounterOp.CounterOp) where + {-# INLINE counter_op #-} + counter_op f_ahSe (Network.Riak.Protocol.DtOp.DtOp x_ahSf x_ahSg x_ahSh) + = fmap (\ y_ahSi -> Network.Riak.Protocol.DtOp.DtOp y_ahSi x_ahSg x_ahSh) (f_ahSe x_ahSf) +class HasMapOp s a | s -> a where + map_op :: Lens' s a +instance HasMapOp Network.Riak.Protocol.DtOp.DtOp (Maybe Network.Riak.Protocol.MapOp.MapOp) where + {-# INLINE map_op #-} + map_op f_ahSj (Network.Riak.Protocol.DtOp.DtOp x_ahSk x_ahSl x_ahSm) + = fmap (\ y_ahSn -> Network.Riak.Protocol.DtOp.DtOp x_ahSk x_ahSl y_ahSn) (f_ahSj x_ahSm) +class HasSetOp s a | s -> a where + set_op :: Lens' s a +instance HasSetOp Network.Riak.Protocol.DtOp.DtOp (Maybe Network.Riak.Protocol.SetOp.SetOp) where + {-# INLINE set_op #-} + set_op f_ahSo (Network.Riak.Protocol.DtOp.DtOp x_ahSp x_ahSq x_ahSr) + = fmap (\ y_ahSs -> Network.Riak.Protocol.DtOp.DtOp x_ahSp y_ahSs x_ahSr) (f_ahSo x_ahSq) +instance HasBucket Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest ByteString where + {-# INLINE bucket #-} + bucket + f_ahUw + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahUx + x_ahUy + x_ahUz + x_ahUA + x_ahUB + x_ahUC + x_ahUD + x_ahUE + x_ahUF + x_ahUG + x_ahUH + x_ahUI + x_ahUJ) + = fmap + (\ y_ahUK + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + y_ahUK x_ahUy x_ahUz x_ahUA x_ahUB x_ahUC x_ahUD x_ahUE x_ahUF x_ahUG x_ahUH x_ahUI x_ahUJ) + (f_ahUw x_ahUx) +instance HasContext Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe ByteString) where + {-# INLINE context #-} + context + f_ahUL + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahUM + x_ahUN + x_ahUO + x_ahUP + x_ahUQ + x_ahUR + x_ahUS + x_ahUT + x_ahUU + x_ahUV + x_ahUW + x_ahUX + x_ahUY) + = fmap + (\ y_ahUZ + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahUM x_ahUN x_ahUO y_ahUZ x_ahUQ x_ahUR x_ahUS x_ahUT x_ahUU x_ahUV x_ahUW x_ahUX x_ahUY) + (f_ahUL x_ahUP) +instance HasDw Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe Word32) where + {-# INLINE dw #-} + dw + f_ahV0 + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahV1 + x_ahV2 + x_ahV3 + x_ahV4 + x_ahV5 + x_ahV6 + x_ahV7 + x_ahV8 + x_ahV9 + x_ahVa + x_ahVb + x_ahVc + x_ahVd) + = fmap + (\ y_ahVe + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahV1 x_ahV2 x_ahV3 x_ahV4 x_ahV5 x_ahV6 y_ahVe x_ahV8 x_ahV9 x_ahVa x_ahVb x_ahVc x_ahVd) + (f_ahV0 x_ahV7) +instance HasIncludeContext Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe Bool) where + {-# INLINE include_context #-} + include_context + f_ahVf + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahVg + x_ahVh + x_ahVi + x_ahVj + x_ahVk + x_ahVl + x_ahVm + x_ahVn + x_ahVo + x_ahVp + x_ahVq + x_ahVr + x_ahVs) + = fmap + (\ y_ahVt + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahVg x_ahVh x_ahVi x_ahVj x_ahVk x_ahVl x_ahVm x_ahVn x_ahVo x_ahVp x_ahVq x_ahVr y_ahVt) + (f_ahVf x_ahVs) +instance HasKey Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe ByteString) where + {-# INLINE key #-} + key + f_ahVu + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahVv + x_ahVw + x_ahVx + x_ahVy + x_ahVz + x_ahVA + x_ahVB + x_ahVC + x_ahVD + x_ahVE + x_ahVF + x_ahVG + x_ahVH) + = fmap + (\ y_ahVI + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahVv y_ahVI x_ahVx x_ahVy x_ahVz x_ahVA x_ahVB x_ahVC x_ahVD x_ahVE x_ahVF x_ahVG x_ahVH) + (f_ahVu x_ahVw) +instance HasNVal Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe Word32) where + {-# INLINE n_val #-} + n_val + f_ahVJ + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahVK + x_ahVL + x_ahVM + x_ahVN + x_ahVO + x_ahVP + x_ahVQ + x_ahVR + x_ahVS + x_ahVT + x_ahVU + x_ahVV + x_ahVW) + = fmap + (\ y_ahVX + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahVK x_ahVL x_ahVM x_ahVN x_ahVO x_ahVP x_ahVQ x_ahVR x_ahVS x_ahVT x_ahVU y_ahVX x_ahVW) + (f_ahVJ x_ahVV) +class HasOp s a | s -> a where + op :: Lens' s a +instance HasOp Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest Network.Riak.Protocol.DtOp.DtOp where + {-# INLINE op #-} + op + f_ahVY + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahVZ + x_ahW0 + x_ahW1 + x_ahW2 + x_ahW3 + x_ahW4 + x_ahW5 + x_ahW6 + x_ahW7 + x_ahW8 + x_ahW9 + x_ahWa + x_ahWb) + = fmap + (\ y_ahWc + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahVZ x_ahW0 x_ahW1 x_ahW2 y_ahWc x_ahW4 x_ahW5 x_ahW6 x_ahW7 x_ahW8 x_ahW9 x_ahWa x_ahWb) + (f_ahVY x_ahW3) +instance HasPw Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe Word32) where + {-# INLINE pw #-} + pw + f_ahWd + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahWe + x_ahWf + x_ahWg + x_ahWh + x_ahWi + x_ahWj + x_ahWk + x_ahWl + x_ahWm + x_ahWn + x_ahWo + x_ahWp + x_ahWq) + = fmap + (\ y_ahWr + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahWe x_ahWf x_ahWg x_ahWh x_ahWi x_ahWj x_ahWk y_ahWr x_ahWm x_ahWn x_ahWo x_ahWp x_ahWq) + (f_ahWd x_ahWl) +class HasReturnBody s a | s -> a where + return_body :: Lens' s a +instance HasReturnBody Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe Bool) where + {-# INLINE return_body #-} + return_body + f_ahWs + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahWt + x_ahWu + x_ahWv + x_ahWw + x_ahWx + x_ahWy + x_ahWz + x_ahWA + x_ahWB + x_ahWC + x_ahWD + x_ahWE + x_ahWF) + = fmap + (\ y_ahWG + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahWt x_ahWu x_ahWv x_ahWw x_ahWx x_ahWy x_ahWz x_ahWA y_ahWG x_ahWC x_ahWD x_ahWE x_ahWF) + (f_ahWs x_ahWB) +instance HasSloppyQuorum Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe Bool) where + {-# INLINE sloppy_quorum #-} + sloppy_quorum + f_ahWH + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahWI + x_ahWJ + x_ahWK + x_ahWL + x_ahWM + x_ahWN + x_ahWO + x_ahWP + x_ahWQ + x_ahWR + x_ahWS + x_ahWT + x_ahWU) + = fmap + (\ y_ahWV + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahWI x_ahWJ x_ahWK x_ahWL x_ahWM x_ahWN x_ahWO x_ahWP x_ahWQ x_ahWR y_ahWV x_ahWT x_ahWU) + (f_ahWH x_ahWS) +instance HasTimeout Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout + f_ahWW + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahWX + x_ahWY + x_ahWZ + x_ahX0 + x_ahX1 + x_ahX2 + x_ahX3 + x_ahX4 + x_ahX5 + x_ahX6 + x_ahX7 + x_ahX8 + x_ahX9) + = fmap + (\ y_ahXa + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahWX x_ahWY x_ahWZ x_ahX0 x_ahX1 x_ahX2 x_ahX3 x_ahX4 x_ahX5 y_ahXa x_ahX7 x_ahX8 x_ahX9) + (f_ahWW x_ahX6) +instance HasType' Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest ByteString where + {-# INLINE type' #-} + type' + f_ahXb + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahXc + x_ahXd + x_ahXe + x_ahXf + x_ahXg + x_ahXh + x_ahXi + x_ahXj + x_ahXk + x_ahXl + x_ahXm + x_ahXn + x_ahXo) + = fmap + (\ y_ahXp + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahXc x_ahXd y_ahXp x_ahXf x_ahXg x_ahXh x_ahXi x_ahXj x_ahXk x_ahXl x_ahXm x_ahXn x_ahXo) + (f_ahXb x_ahXe) +instance HasW Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest (Maybe Word32) where + {-# INLINE w #-} + w f_ahXq + (Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest x_ahXr + x_ahXs + x_ahXt + x_ahXu + x_ahXv + x_ahXw + x_ahXx + x_ahXy + x_ahXz + x_ahXA + x_ahXB + x_ahXC + x_ahXD) + = fmap + (\ y_ahXE + -> Network.Riak.Protocol.DtUpdateRequest.DtUpdateRequest + x_ahXr x_ahXs x_ahXt x_ahXu x_ahXv y_ahXE x_ahXx x_ahXy x_ahXz x_ahXA x_ahXB x_ahXC x_ahXD) + (f_ahXq x_ahXw) +instance HasContext Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse (Maybe ByteString) where + {-# INLINE context #-} + context f_ai1y (Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse x_ai1z x_ai1A x_ai1B x_ai1C x_ai1D) + = fmap (\ y_ai1E -> Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse x_ai1z y_ai1E x_ai1B x_ai1C x_ai1D) (f_ai1y x_ai1A) +class HasCounterValue s a | s -> a where + counter_value :: Lens' s a +instance HasCounterValue Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse (Maybe Int64) where + {-# INLINE counter_value #-} + counter_value f_ai1F (Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse x_ai1G x_ai1H x_ai1I x_ai1J x_ai1K) + = fmap (\ y_ai1L -> Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse x_ai1G x_ai1H y_ai1L x_ai1J x_ai1K) (f_ai1F x_ai1I) +instance HasKey Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse (Maybe ByteString) where + {-# INLINE key #-} + key f_ai1M (Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse x_ai1N x_ai1O x_ai1P x_ai1Q x_ai1R) + = fmap (\ y_ai1S -> Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse y_ai1S x_ai1O x_ai1P x_ai1Q x_ai1R) (f_ai1M x_ai1N) +class HasMapValue s a | s -> a where + map_value :: Lens' s a +instance HasMapValue Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse (Seq Network.Riak.Protocol.MapEntry.MapEntry) where + {-# INLINE map_value #-} + map_value f_ai1T (Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse x_ai1U x_ai1V x_ai1W x_ai1X x_ai1Y) + = fmap (\ y_ai1Z -> Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse x_ai1U x_ai1V x_ai1W x_ai1X y_ai1Z) (f_ai1T x_ai1Y) +class HasSetValue s a | s -> a where + set_value :: Lens' s a +instance HasSetValue Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse (Seq ByteString) where + {-# INLINE set_value #-} + set_value f_ai20 (Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse x_ai21 x_ai22 x_ai23 x_ai24 x_ai25) + = fmap (\ y_ai26 -> Network.Riak.Protocol.DtUpdateResponse.DtUpdateResponse x_ai21 x_ai22 x_ai23 y_ai26 x_ai25) (f_ai20 x_ai24) +instance HasCounterValue Network.Riak.Protocol.DtValue.DtValue (Maybe Int64) where + {-# INLINE counter_value #-} + counter_value f_ai4C (Network.Riak.Protocol.DtValue.DtValue x_ai4D x_ai4E x_ai4F) + = fmap (\ y_ai4G -> Network.Riak.Protocol.DtValue.DtValue y_ai4G x_ai4E x_ai4F) (f_ai4C x_ai4D) +instance HasMapValue Network.Riak.Protocol.DtValue.DtValue (Seq Network.Riak.Protocol.MapEntry.MapEntry) where + {-# INLINE map_value #-} + map_value f_ai4H (Network.Riak.Protocol.DtValue.DtValue x_ai4I x_ai4J x_ai4K) + = fmap (\ y_ai4L -> Network.Riak.Protocol.DtValue.DtValue x_ai4I x_ai4J y_ai4L) (f_ai4H x_ai4K) +instance HasSetValue Network.Riak.Protocol.DtValue.DtValue (Seq ByteString) where + {-# INLINE set_value #-} + set_value f_ai4M (Network.Riak.Protocol.DtValue.DtValue x_ai4N x_ai4O x_ai4P) + = fmap (\ y_ai4Q -> Network.Riak.Protocol.DtValue.DtValue x_ai4N y_ai4Q x_ai4P) (f_ai4M x_ai4O) +class HasErrcode s a | s -> a where + errcode :: Lens' s a +instance HasErrcode Network.Riak.Protocol.ErrorResponse.ErrorResponse Word32 where + {-# INLINE errcode #-} + errcode f_ai5E (Network.Riak.Protocol.ErrorResponse.ErrorResponse x_ai5F x_ai5G) + = fmap (\ y_ai5H -> Network.Riak.Protocol.ErrorResponse.ErrorResponse x_ai5F y_ai5H) (f_ai5E x_ai5G) +class HasErrmsg s a | s -> a where + errmsg :: Lens' s a +instance HasErrmsg Network.Riak.Protocol.ErrorResponse.ErrorResponse ByteString where + {-# INLINE errmsg #-} + errmsg f_ai5I (Network.Riak.Protocol.ErrorResponse.ErrorResponse x_ai5J x_ai5K) + = fmap (\ y_ai5L -> Network.Riak.Protocol.ErrorResponse.ErrorResponse y_ai5L x_ai5K) (f_ai5I x_ai5J) +instance HasBucket Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest ByteString where + {-# INLINE bucket #-} + bucket f_ai7c (Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest x_ai7d x_ai7e x_ai7f) + = fmap + (\ y_ai7g -> Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest y_ai7g x_ai7e x_ai7f) (f_ai7c x_ai7d) +instance HasKey Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest ByteString where + {-# INLINE key #-} + key f_ai7h (Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest x_ai7i x_ai7j x_ai7k) + = fmap + (\ y_ai7l -> Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest x_ai7i y_ai7l x_ai7k) (f_ai7h x_ai7j) +instance HasType' Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' f_ai7m (Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest x_ai7n x_ai7o x_ai7p) + = fmap + (\ y_ai7q -> Network.Riak.Protocol.GetBucketKeyPreflistRequest.GetBucketKeyPreflistRequest x_ai7n x_ai7o y_ai7q) (f_ai7m x_ai7p) +class HasPreflist s a | s -> a where + preflist :: Lens' s a +instance HasPreflist Network.Riak.Protocol.GetBucketKeyPreflistResponse.GetBucketKeyPreflistResponse (Seq Network.Riak.Protocol.BucketKeyPreflistItem.BucketKeyPreflistItem) where + {-# INLINE preflist #-} + preflist f_ai8e (Network.Riak.Protocol.GetBucketKeyPreflistResponse.GetBucketKeyPreflistResponse x_ai8f) + = fmap (\ y_ai8g -> Network.Riak.Protocol.GetBucketKeyPreflistResponse.GetBucketKeyPreflistResponse y_ai8g) (f_ai8e x_ai8f) +instance HasBucket Network.Riak.Protocol.GetBucketRequest.GetBucketRequest ByteString where + {-# INLINE bucket #-} + bucket f_ai92 (Network.Riak.Protocol.GetBucketRequest.GetBucketRequest x_ai93 x_ai94) + = fmap (\ y_ai95 -> Network.Riak.Protocol.GetBucketRequest.GetBucketRequest y_ai95 x_ai94) (f_ai92 x_ai93) +instance HasType' Network.Riak.Protocol.GetBucketRequest.GetBucketRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' f_ai96 (Network.Riak.Protocol.GetBucketRequest.GetBucketRequest x_ai97 x_ai98) + = fmap (\ y_ai99 -> Network.Riak.Protocol.GetBucketRequest.GetBucketRequest x_ai97 y_ai99) (f_ai96 x_ai98) +class HasProps s a | s -> a where + props :: Lens' s a +instance HasProps Network.Riak.Protocol.GetBucketResponse.GetBucketResponse Network.Riak.Protocol.BucketProps.BucketProps where + {-# INLINE props #-} + props f_ai9J (Network.Riak.Protocol.GetBucketResponse.GetBucketResponse x_ai9K) + = fmap (\ y_ai9L -> Network.Riak.Protocol.GetBucketResponse.GetBucketResponse y_ai9L) (f_ai9J x_ai9K) +instance HasType' Network.Riak.Protocol.GetBucketTypeRequest.GetBucketTypeRequest ByteString where + {-# INLINE type' #-} + type' f_aiax (Network.Riak.Protocol.GetBucketTypeRequest.GetBucketTypeRequest x_aiay) + = fmap (\ y_aiaz -> Network.Riak.Protocol.GetBucketTypeRequest.GetBucketTypeRequest y_aiaz) (f_aiax x_aiay) +class HasClientId s a | s -> a where + client_id :: Lens' s a +instance HasClientId Network.Riak.Protocol.GetClientIDResponse.GetClientIDResponse ByteString where + {-# INLINE client_id #-} + client_id f_aib2 (Network.Riak.Protocol.GetClientIDResponse.GetClientIDResponse x_aib3) + = fmap (\ y_aib4 -> Network.Riak.Protocol.GetClientIDResponse.GetClientIDResponse y_aib4) (f_aib2 x_aib3) +instance HasBasicQuorum Network.Riak.Protocol.GetRequest.GetRequest (Maybe Bool) where + {-# INLINE basic_quorum #-} + basic_quorum + f_aibQ + (Network.Riak.Protocol.GetRequest.GetRequest x_aibR + x_aibS + x_aibT + x_aibU + x_aibV + x_aibW + x_aibX + x_aibY + x_aibZ + x_aic0 + x_aic1 + x_aic2 + x_aic3) + = fmap + (\ y_aic4 + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aibR x_aibS x_aibT x_aibU y_aic4 x_aibW x_aibX x_aibY x_aibZ x_aic0 x_aic1 x_aic2 x_aic3) + (f_aibQ x_aibV) +instance HasBucket Network.Riak.Protocol.GetRequest.GetRequest ByteString where + {-# INLINE bucket #-} + bucket + f_aic5 + (Network.Riak.Protocol.GetRequest.GetRequest x_aic6 + x_aic7 + x_aic8 + x_aic9 + x_aica + x_aicb + x_aicc + x_aicd + x_aice + x_aicf + x_aicg + x_aich + x_aici) + = fmap + (\ y_aicj + -> Network.Riak.Protocol.GetRequest.GetRequest + y_aicj x_aic7 x_aic8 x_aic9 x_aica x_aicb x_aicc x_aicd x_aice x_aicf x_aicg x_aich x_aici) + (f_aic5 x_aic6) +class HasDeletedvclock s a | s -> a where + deletedvclock :: Lens' s a +instance HasDeletedvclock Network.Riak.Protocol.GetRequest.GetRequest (Maybe Bool) where + {-# INLINE deletedvclock #-} + deletedvclock + f_aick + (Network.Riak.Protocol.GetRequest.GetRequest x_aicl + x_aicm + x_aicn + x_aico + x_aicp + x_aicq + x_aicr + x_aics + x_aict + x_aicu + x_aicv + x_aicw + x_aicx) + = fmap + (\ y_aicy + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aicl x_aicm x_aicn x_aico x_aicp x_aicq x_aicr x_aics y_aicy x_aicu x_aicv x_aicw x_aicx) + (f_aick x_aict) +class HasHead s a | s -> a where + head :: Lens' s a +instance HasHead Network.Riak.Protocol.GetRequest.GetRequest (Maybe Bool) where + {-# INLINE head #-} + head + f_aicz + (Network.Riak.Protocol.GetRequest.GetRequest x_aicA + x_aicB + x_aicC + x_aicD + x_aicE + x_aicF + x_aicG + x_aicH + x_aicI + x_aicJ + x_aicK + x_aicL + x_aicM) + = fmap + (\ y_aicN + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aicA x_aicB x_aicC x_aicD x_aicE x_aicF x_aicG y_aicN x_aicI x_aicJ x_aicK x_aicL x_aicM) + (f_aicz x_aicH) +class HasIfModified s a | s -> a where + if_modified :: Lens' s a +instance HasIfModified Network.Riak.Protocol.GetRequest.GetRequest (Maybe ByteString) where + {-# INLINE if_modified #-} + if_modified + f_aicO + (Network.Riak.Protocol.GetRequest.GetRequest x_aicP + x_aicQ + x_aicR + x_aicS + x_aicT + x_aicU + x_aicV + x_aicW + x_aicX + x_aicY + x_aicZ + x_aid0 + x_aid1) + = fmap + (\ y_aid2 + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aicP x_aicQ x_aicR x_aicS x_aicT x_aicU y_aid2 x_aicW x_aicX x_aicY x_aicZ x_aid0 x_aid1) + (f_aicO x_aicV) +instance HasKey Network.Riak.Protocol.GetRequest.GetRequest ByteString where + {-# INLINE key #-} + key + f_aid3 + (Network.Riak.Protocol.GetRequest.GetRequest x_aid4 + x_aid5 + x_aid6 + x_aid7 + x_aid8 + x_aid9 + x_aida + x_aidb + x_aidc + x_aidd + x_aide + x_aidf + x_aidg) + = fmap + (\ y_aidh + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aid4 y_aidh x_aid6 x_aid7 x_aid8 x_aid9 x_aida x_aidb x_aidc x_aidd x_aide x_aidf x_aidg) + (f_aid3 x_aid5) +instance HasNVal Network.Riak.Protocol.GetRequest.GetRequest (Maybe Word32) where + {-# INLINE n_val #-} + n_val + f_aidi + (Network.Riak.Protocol.GetRequest.GetRequest x_aidj + x_aidk + x_aidl + x_aidm + x_aidn + x_aido + x_aidp + x_aidq + x_aidr + x_aids + x_aidt + x_aidu + x_aidv) + = fmap + (\ y_aidw + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aidj x_aidk x_aidl x_aidm x_aidn x_aido x_aidp x_aidq x_aidr x_aids x_aidt y_aidw x_aidv) + (f_aidi x_aidu) +instance HasNotfoundOk Network.Riak.Protocol.GetRequest.GetRequest (Maybe Bool) where + {-# INLINE notfound_ok #-} + notfound_ok + f_aidx + (Network.Riak.Protocol.GetRequest.GetRequest x_aidy + x_aidz + x_aidA + x_aidB + x_aidC + x_aidD + x_aidE + x_aidF + x_aidG + x_aidH + x_aidI + x_aidJ + x_aidK) + = fmap + (\ y_aidL + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aidy x_aidz x_aidA x_aidB x_aidC y_aidL x_aidE x_aidF x_aidG x_aidH x_aidI x_aidJ x_aidK) + (f_aidx x_aidD) +instance HasPr Network.Riak.Protocol.GetRequest.GetRequest (Maybe Word32) where + {-# INLINE pr #-} + pr + f_aidM + (Network.Riak.Protocol.GetRequest.GetRequest x_aidN + x_aidO + x_aidP + x_aidQ + x_aidR + x_aidS + x_aidT + x_aidU + x_aidV + x_aidW + x_aidX + x_aidY + x_aidZ) + = fmap + (\ y_aie0 + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aidN x_aidO x_aidP y_aie0 x_aidR x_aidS x_aidT x_aidU x_aidV x_aidW x_aidX x_aidY x_aidZ) + (f_aidM x_aidQ) +instance HasR Network.Riak.Protocol.GetRequest.GetRequest (Maybe Word32) where + {-# INLINE r #-} + r f_aie1 + (Network.Riak.Protocol.GetRequest.GetRequest x_aie2 + x_aie3 + x_aie4 + x_aie5 + x_aie6 + x_aie7 + x_aie8 + x_aie9 + x_aiea + x_aieb + x_aiec + x_aied + x_aiee) + = fmap + (\ y_aief + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aie2 x_aie3 y_aief x_aie5 x_aie6 x_aie7 x_aie8 x_aie9 x_aiea x_aieb x_aiec x_aied x_aiee) + (f_aie1 x_aie4) +instance HasSloppyQuorum Network.Riak.Protocol.GetRequest.GetRequest (Maybe Bool) where + {-# INLINE sloppy_quorum #-} + sloppy_quorum + f_aieg + (Network.Riak.Protocol.GetRequest.GetRequest x_aieh + x_aiei + x_aiej + x_aiek + x_aiel + x_aiem + x_aien + x_aieo + x_aiep + x_aieq + x_aier + x_aies + x_aiet) + = fmap + (\ y_aieu + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aieh x_aiei x_aiej x_aiek x_aiel x_aiem x_aien x_aieo x_aiep x_aieq y_aieu x_aies x_aiet) + (f_aieg x_aier) +instance HasTimeout Network.Riak.Protocol.GetRequest.GetRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout + f_aiev + (Network.Riak.Protocol.GetRequest.GetRequest x_aiew + x_aiex + x_aiey + x_aiez + x_aieA + x_aieB + x_aieC + x_aieD + x_aieE + x_aieF + x_aieG + x_aieH + x_aieI) + = fmap + (\ y_aieJ + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aiew x_aiex x_aiey x_aiez x_aieA x_aieB x_aieC x_aieD x_aieE y_aieJ x_aieG x_aieH x_aieI) + (f_aiev x_aieF) +instance HasType' Network.Riak.Protocol.GetRequest.GetRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' + f_aieK + (Network.Riak.Protocol.GetRequest.GetRequest x_aieL + x_aieM + x_aieN + x_aieO + x_aieP + x_aieQ + x_aieR + x_aieS + x_aieT + x_aieU + x_aieV + x_aieW + x_aieX) + = fmap + (\ y_aieY + -> Network.Riak.Protocol.GetRequest.GetRequest + x_aieL x_aieM x_aieN x_aieO x_aieP x_aieQ x_aieR x_aieS x_aieT x_aieU x_aieV x_aieW y_aieY) + (f_aieK x_aieX) +class HasContent s a | s -> a where + content :: Lens' s a +instance HasContent Network.Riak.Protocol.GetResponse.GetResponse (Seq Network.Riak.Protocol.Content.Content) where + {-# INLINE content #-} + content f_aiji (Network.Riak.Protocol.GetResponse.GetResponse x_aijj x_aijk x_aijl) + = fmap (\ y_aijm -> Network.Riak.Protocol.GetResponse.GetResponse y_aijm x_aijk x_aijl) (f_aiji x_aijj) +class HasUnchanged s a | s -> a where + unchanged :: Lens' s a +instance HasUnchanged Network.Riak.Protocol.GetResponse.GetResponse (Maybe Bool) where + {-# INLINE unchanged #-} + unchanged f_aijn (Network.Riak.Protocol.GetResponse.GetResponse x_aijo x_aijp x_aijq) + = fmap (\ y_aijr -> Network.Riak.Protocol.GetResponse.GetResponse x_aijo x_aijp y_aijr) (f_aijn x_aijq) +instance HasVclock Network.Riak.Protocol.GetResponse.GetResponse (Maybe ByteString) where + {-# INLINE vclock #-} + vclock f_aijs (Network.Riak.Protocol.GetResponse.GetResponse x_aijt x_aiju x_aijv) + = fmap (\ y_aijw -> Network.Riak.Protocol.GetResponse.GetResponse x_aijt y_aijw x_aijv) (f_aijs x_aiju) +instance HasKey Network.Riak.Protocol.IndexObject.IndexObject ByteString where + {-# INLINE key #-} + key f_ailh (Network.Riak.Protocol.IndexObject.IndexObject x_aili x_ailj) + = fmap (\ y_ailk -> Network.Riak.Protocol.IndexObject.IndexObject y_ailk x_ailj) (f_ailh x_aili) +class HasObject s a | s -> a where + object :: Lens' s a +instance HasObject Network.Riak.Protocol.IndexObject.IndexObject Network.Riak.Protocol.GetResponse.GetResponse where + {-# INLINE object #-} + object f_aill (Network.Riak.Protocol.IndexObject.IndexObject x_ailm x_ailn) + = fmap (\ y_ailo -> Network.Riak.Protocol.IndexObject.IndexObject x_ailm y_ailo) (f_aill x_ailn) +instance HasBucket Network.Riak.Protocol.IndexRequest.IndexRequest ByteString where + {-# INLINE bucket #-} + bucket + f_aimo + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aimp + x_aimq + x_aimr + x_aims + x_aimt + x_aimu + x_aimv + x_aimw + x_aimx + x_aimy + x_aimz + x_aimA + x_aimB + x_aimC) + = fmap + (\ y_aimD + -> Network.Riak.Protocol.IndexRequest.IndexRequest + y_aimD x_aimq x_aimr x_aims x_aimt x_aimu x_aimv x_aimw x_aimx x_aimy x_aimz x_aimA x_aimB x_aimC) + (f_aimo x_aimp) +instance HasContinuation Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe ByteString) where + {-# INLINE continuation #-} + continuation + f_aimE + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aimF + x_aimG + x_aimH + x_aimI + x_aimJ + x_aimK + x_aimL + x_aimM + x_aimN + x_aimO + x_aimP + x_aimQ + x_aimR + x_aimS) + = fmap + (\ y_aimT + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_aimF x_aimG x_aimH x_aimI x_aimJ x_aimK x_aimL x_aimM x_aimN y_aimT x_aimP x_aimQ x_aimR x_aimS) + (f_aimE x_aimO) +class HasIndex s a | s -> a where + index :: Lens' s a +instance HasIndex Network.Riak.Protocol.IndexRequest.IndexRequest ByteString where + {-# INLINE index #-} + index + f_aimU + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aimV + x_aimW + x_aimX + x_aimY + x_aimZ + x_ain0 + x_ain1 + x_ain2 + x_ain3 + x_ain4 + x_ain5 + x_ain6 + x_ain7 + x_ain8) + = fmap + (\ y_ain9 + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_aimV y_ain9 x_aimX x_aimY x_aimZ x_ain0 x_ain1 x_ain2 x_ain3 x_ain4 x_ain5 x_ain6 x_ain7 x_ain8) + (f_aimU x_aimW) +instance HasKey Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe ByteString) where + {-# INLINE key #-} + key + f_aina + (Network.Riak.Protocol.IndexRequest.IndexRequest x_ainb + x_ainc + x_aind + x_aine + x_ainf + x_aing + x_ainh + x_aini + x_ainj + x_aink + x_ainl + x_ainm + x_ainn + x_aino) + = fmap + (\ y_ainp + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_ainb x_ainc x_aind y_ainp x_ainf x_aing x_ainh x_aini x_ainj x_aink x_ainl x_ainm x_ainn x_aino) + (f_aina x_aine) +instance HasMaxResults Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe Word32) where + {-# INLINE max_results #-} + max_results + f_ainq + (Network.Riak.Protocol.IndexRequest.IndexRequest x_ainr + x_ains + x_aint + x_ainu + x_ainv + x_ainw + x_ainx + x_ainy + x_ainz + x_ainA + x_ainB + x_ainC + x_ainD + x_ainE) + = fmap + (\ y_ainF + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_ainr x_ains x_aint x_ainu x_ainv x_ainw x_ainx x_ainy y_ainF x_ainA x_ainB x_ainC x_ainD x_ainE) + (f_ainq x_ainz) +class HasPaginationSort s a | s -> a where + pagination_sort :: Lens' s a +instance HasPaginationSort Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe Bool) where + {-# INLINE pagination_sort #-} + pagination_sort + f_ainG + (Network.Riak.Protocol.IndexRequest.IndexRequest x_ainH + x_ainI + x_ainJ + x_ainK + x_ainL + x_ainM + x_ainN + x_ainO + x_ainP + x_ainQ + x_ainR + x_ainS + x_ainT + x_ainU) + = fmap + (\ y_ainV + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_ainH x_ainI x_ainJ x_ainK x_ainL x_ainM x_ainN x_ainO x_ainP x_ainQ x_ainR x_ainS x_ainT y_ainV) + (f_ainG x_ainU) +class HasQtype s a | s -> a where + qtype :: Lens' s a +instance HasQtype Network.Riak.Protocol.IndexRequest.IndexRequest Network.Riak.Protocol.IndexRequest.IndexQueryType.IndexQueryType where + {-# INLINE qtype #-} + qtype + f_ainW + (Network.Riak.Protocol.IndexRequest.IndexRequest x_ainX + x_ainY + x_ainZ + x_aio0 + x_aio1 + x_aio2 + x_aio3 + x_aio4 + x_aio5 + x_aio6 + x_aio7 + x_aio8 + x_aio9 + x_aioa) + = fmap + (\ y_aiob + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_ainX x_ainY y_aiob x_aio0 x_aio1 x_aio2 x_aio3 x_aio4 x_aio5 x_aio6 x_aio7 x_aio8 x_aio9 x_aioa) + (f_ainW x_ainZ) +class HasRangeMax s a | s -> a where + range_max :: Lens' s a +instance HasRangeMax Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe ByteString) where + {-# INLINE range_max #-} + range_max + f_aioc + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aiod + x_aioe + x_aiof + x_aiog + x_aioh + x_aioi + x_aioj + x_aiok + x_aiol + x_aiom + x_aion + x_aioo + x_aiop + x_aioq) + = fmap + (\ y_aior + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_aiod x_aioe x_aiof x_aiog x_aioh y_aior x_aioj x_aiok x_aiol x_aiom x_aion x_aioo x_aiop x_aioq) + (f_aioc x_aioi) +class HasRangeMin s a | s -> a where + range_min :: Lens' s a +instance HasRangeMin Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe ByteString) where + {-# INLINE range_min #-} + range_min + f_aios + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aiot + x_aiou + x_aiov + x_aiow + x_aiox + x_aioy + x_aioz + x_aioA + x_aioB + x_aioC + x_aioD + x_aioE + x_aioF + x_aioG) + = fmap + (\ y_aioH + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_aiot x_aiou x_aiov x_aiow y_aioH x_aioy x_aioz x_aioA x_aioB x_aioC x_aioD x_aioE x_aioF x_aioG) + (f_aios x_aiox) +class HasReturnTerms s a | s -> a where + return_terms :: Lens' s a +instance HasReturnTerms Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe Bool) where + {-# INLINE return_terms #-} + return_terms + f_aioI + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aioJ + x_aioK + x_aioL + x_aioM + x_aioN + x_aioO + x_aioP + x_aioQ + x_aioR + x_aioS + x_aioT + x_aioU + x_aioV + x_aioW) + = fmap + (\ y_aioX + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_aioJ x_aioK x_aioL x_aioM x_aioN x_aioO y_aioX x_aioQ x_aioR x_aioS x_aioT x_aioU x_aioV x_aioW) + (f_aioI x_aioP) +class HasStream s a | s -> a where + stream :: Lens' s a +instance HasStream Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe Bool) where + {-# INLINE stream #-} + stream + f_aioY + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aioZ + x_aip0 + x_aip1 + x_aip2 + x_aip3 + x_aip4 + x_aip5 + x_aip6 + x_aip7 + x_aip8 + x_aip9 + x_aipa + x_aipb + x_aipc) + = fmap + (\ y_aipd + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_aioZ x_aip0 x_aip1 x_aip2 x_aip3 x_aip4 x_aip5 y_aipd x_aip7 x_aip8 x_aip9 x_aipa x_aipb x_aipc) + (f_aioY x_aip6) +class HasTermRegex s a | s -> a where + term_regex :: Lens' s a +instance HasTermRegex Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe ByteString) where + {-# INLINE term_regex #-} + term_regex + f_aipe + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aipf + x_aipg + x_aiph + x_aipi + x_aipj + x_aipk + x_aipl + x_aipm + x_aipn + x_aipo + x_aipp + x_aipq + x_aipr + x_aips) + = fmap + (\ y_aipt + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_aipf x_aipg x_aiph x_aipi x_aipj x_aipk x_aipl x_aipm x_aipn x_aipo x_aipp x_aipq y_aipt x_aips) + (f_aipe x_aipr) +instance HasTimeout Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout + f_aipu + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aipv + x_aipw + x_aipx + x_aipy + x_aipz + x_aipA + x_aipB + x_aipC + x_aipD + x_aipE + x_aipF + x_aipG + x_aipH + x_aipI) + = fmap + (\ y_aipJ + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_aipv x_aipw x_aipx x_aipy x_aipz x_aipA x_aipB x_aipC x_aipD x_aipE y_aipJ x_aipG x_aipH x_aipI) + (f_aipu x_aipF) +instance HasType' Network.Riak.Protocol.IndexRequest.IndexRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' + f_aipK + (Network.Riak.Protocol.IndexRequest.IndexRequest x_aipL + x_aipM + x_aipN + x_aipO + x_aipP + x_aipQ + x_aipR + x_aipS + x_aipT + x_aipU + x_aipV + x_aipW + x_aipX + x_aipY) + = fmap + (\ y_aipZ + -> Network.Riak.Protocol.IndexRequest.IndexRequest + x_aipL x_aipM x_aipN x_aipO x_aipP x_aipQ x_aipR x_aipS x_aipT x_aipU x_aipV y_aipZ x_aipX x_aipY) + (f_aipK x_aipW) +instance HasContinuation Network.Riak.Protocol.IndexResponse.IndexResponse (Maybe ByteString) where + {-# INLINE continuation #-} + continuation f_aiwD (Network.Riak.Protocol.IndexResponse.IndexResponse x_aiwE x_aiwF x_aiwG x_aiwH) + = fmap (\ y_aiwI -> Network.Riak.Protocol.IndexResponse.IndexResponse x_aiwE x_aiwF y_aiwI x_aiwH) (f_aiwD x_aiwG) +instance HasDone Network.Riak.Protocol.IndexResponse.IndexResponse (Maybe Bool) where + {-# INLINE done #-} + done f_aiwJ (Network.Riak.Protocol.IndexResponse.IndexResponse x_aiwK x_aiwL x_aiwM x_aiwN) + = fmap (\ y_aiwO -> Network.Riak.Protocol.IndexResponse.IndexResponse x_aiwK x_aiwL x_aiwM y_aiwO) (f_aiwJ x_aiwN) +class HasKeys s a | s -> a where + keys :: Lens' s a +instance HasKeys Network.Riak.Protocol.IndexResponse.IndexResponse (Seq ByteString) where + {-# INLINE keys #-} + keys f_aiwP (Network.Riak.Protocol.IndexResponse.IndexResponse x_aiwQ x_aiwR x_aiwS x_aiwT) + = fmap (\ y_aiwU -> Network.Riak.Protocol.IndexResponse.IndexResponse y_aiwU x_aiwR x_aiwS x_aiwT) (f_aiwP x_aiwQ) +class HasResults s a | s -> a where + results :: Lens' s a +instance HasResults Network.Riak.Protocol.IndexResponse.IndexResponse (Seq Network.Riak.Protocol.Pair.Pair) where + {-# INLINE results #-} + results f_aiwV (Network.Riak.Protocol.IndexResponse.IndexResponse x_aiwW x_aiwX x_aiwY x_aiwZ) + = fmap (\ y_aix0 -> Network.Riak.Protocol.IndexResponse.IndexResponse x_aiwW y_aix0 x_aiwY x_aiwZ) (f_aiwV x_aiwX) +instance HasBucket Network.Riak.Protocol.Link.Link (Maybe ByteString) where + {-# INLINE bucket #-} + bucket f_aiyS (Network.Riak.Protocol.Link.Link x_aiyT x_aiyU x_aiyV) + = fmap (\ y_aiyW -> Network.Riak.Protocol.Link.Link y_aiyW x_aiyU x_aiyV) (f_aiyS x_aiyT) +instance HasKey Network.Riak.Protocol.Link.Link (Maybe ByteString) where + {-# INLINE key #-} + key f_aiyX (Network.Riak.Protocol.Link.Link x_aiyY x_aiyZ x_aiz0) + = fmap (\ y_aiz1 -> Network.Riak.Protocol.Link.Link x_aiyY y_aiz1 x_aiz0) (f_aiyX x_aiyZ) +class HasTag s a | s -> a where + tag :: Lens' s a +instance HasTag Network.Riak.Protocol.Link.Link (Maybe ByteString) where + {-# INLINE tag #-} + tag f_aiz2 (Network.Riak.Protocol.Link.Link x_aiz3 x_aiz4 x_aiz5) + = fmap (\ y_aiz6 -> Network.Riak.Protocol.Link.Link x_aiz3 x_aiz4 y_aiz6) (f_aiz2 x_aiz5) +instance HasStream Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest (Maybe Bool) where + {-# INLINE stream #-} + stream f_aiAk (Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest x_aiAl x_aiAm x_aiAn) + = fmap (\ y_aiAo -> Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest x_aiAl y_aiAo x_aiAn) (f_aiAk x_aiAm) +instance HasTimeout Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout f_aiAp (Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest x_aiAq x_aiAr x_aiAs) + = fmap (\ y_aiAt -> Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest y_aiAt x_aiAr x_aiAs) (f_aiAp x_aiAq) +instance HasType' Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' f_aiAu (Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest x_aiAv x_aiAw x_aiAx) + = fmap (\ y_aiAy -> Network.Riak.Protocol.ListBucketsRequest.ListBucketsRequest x_aiAv x_aiAw y_aiAy) (f_aiAu x_aiAx) +class HasBuckets s a | s -> a where + buckets :: Lens' s a +instance HasBuckets Network.Riak.Protocol.ListBucketsResponse.ListBucketsResponse (Seq ByteString) where + {-# INLINE buckets #-} + buckets f_aiBm (Network.Riak.Protocol.ListBucketsResponse.ListBucketsResponse x_aiBn x_aiBo) + = fmap (\ y_aiBp -> Network.Riak.Protocol.ListBucketsResponse.ListBucketsResponse y_aiBp x_aiBo) (f_aiBm x_aiBn) +instance HasDone Network.Riak.Protocol.ListBucketsResponse.ListBucketsResponse (Maybe Bool) where + {-# INLINE done #-} + done f_aiBq (Network.Riak.Protocol.ListBucketsResponse.ListBucketsResponse x_aiBr x_aiBs) + = fmap (\ y_aiBt -> Network.Riak.Protocol.ListBucketsResponse.ListBucketsResponse x_aiBr y_aiBt) (f_aiBq x_aiBs) +instance HasBucket Network.Riak.Protocol.ListKeysRequest.ListKeysRequest ByteString where + {-# INLINE bucket #-} + bucket f_aiCt (Network.Riak.Protocol.ListKeysRequest.ListKeysRequest x_aiCu x_aiCv x_aiCw) + = fmap (\ y_aiCx -> Network.Riak.Protocol.ListKeysRequest.ListKeysRequest y_aiCx x_aiCv x_aiCw) (f_aiCt x_aiCu) +instance HasTimeout Network.Riak.Protocol.ListKeysRequest.ListKeysRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout f_aiCy (Network.Riak.Protocol.ListKeysRequest.ListKeysRequest x_aiCz x_aiCA x_aiCB) + = fmap (\ y_aiCC -> Network.Riak.Protocol.ListKeysRequest.ListKeysRequest x_aiCz y_aiCC x_aiCB) (f_aiCy x_aiCA) +instance HasType' Network.Riak.Protocol.ListKeysRequest.ListKeysRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' f_aiCD (Network.Riak.Protocol.ListKeysRequest.ListKeysRequest x_aiCE x_aiCF x_aiCG) + = fmap (\ y_aiCH -> Network.Riak.Protocol.ListKeysRequest.ListKeysRequest x_aiCE x_aiCF y_aiCH) (f_aiCD x_aiCG) +instance HasDone Network.Riak.Protocol.ListKeysResponse.ListKeysResponse (Maybe Bool) where + {-# INLINE done #-} + done f_aiDv (Network.Riak.Protocol.ListKeysResponse.ListKeysResponse x_aiDw x_aiDx) + = fmap (\ y_aiDy -> Network.Riak.Protocol.ListKeysResponse.ListKeysResponse x_aiDw y_aiDy) (f_aiDv x_aiDx) +instance HasKeys Network.Riak.Protocol.ListKeysResponse.ListKeysResponse (Seq ByteString) where + {-# INLINE keys #-} + keys f_aiDz (Network.Riak.Protocol.ListKeysResponse.ListKeysResponse x_aiDA x_aiDB) + = fmap (\ y_aiDC -> Network.Riak.Protocol.ListKeysResponse.ListKeysResponse y_aiDC x_aiDB) (f_aiDz x_aiDA) +instance HasCounterValue Network.Riak.Protocol.MapEntry.MapEntry (Maybe Int64) where + {-# INLINE counter_value #-} + counter_value f_aiEc (Network.Riak.Protocol.MapEntry.MapEntry x_aiEd x_aiEe x_aiEf x_aiEg x_aiEh x_aiEi) + = fmap (\ y_aiEj -> Network.Riak.Protocol.MapEntry.MapEntry x_aiEd y_aiEj x_aiEf x_aiEg x_aiEh x_aiEi) (f_aiEc x_aiEe) +class HasField s a | s -> a where + field :: Lens' s a +instance HasField Network.Riak.Protocol.MapEntry.MapEntry Network.Riak.Protocol.MapField.MapField where + {-# INLINE field #-} + field f_aiEk (Network.Riak.Protocol.MapEntry.MapEntry x_aiEl x_aiEm x_aiEn x_aiEo x_aiEp x_aiEq) + = fmap (\ y_aiEr -> Network.Riak.Protocol.MapEntry.MapEntry y_aiEr x_aiEm x_aiEn x_aiEo x_aiEp x_aiEq) (f_aiEk x_aiEl) +class HasFlagValue s a | s -> a where + flag_value :: Lens' s a +instance HasFlagValue Network.Riak.Protocol.MapEntry.MapEntry (Maybe Bool) where + {-# INLINE flag_value #-} + flag_value f_aiEs (Network.Riak.Protocol.MapEntry.MapEntry x_aiEt x_aiEu x_aiEv x_aiEw x_aiEx x_aiEy) + = fmap (\ y_aiEz -> Network.Riak.Protocol.MapEntry.MapEntry x_aiEt x_aiEu x_aiEv x_aiEw y_aiEz x_aiEy) (f_aiEs x_aiEx) +instance HasMapValue Network.Riak.Protocol.MapEntry.MapEntry (Seq Network.Riak.Protocol.MapEntry.MapEntry) where + {-# INLINE map_value #-} + map_value f_aiEA (Network.Riak.Protocol.MapEntry.MapEntry x_aiEB x_aiEC x_aiED x_aiEE x_aiEF x_aiEG) + = fmap (\ y_aiEH -> Network.Riak.Protocol.MapEntry.MapEntry x_aiEB x_aiEC x_aiED x_aiEE x_aiEF y_aiEH) (f_aiEA x_aiEG) +class HasRegisterValue s a | s -> a where + register_value :: Lens' s a +instance HasRegisterValue Network.Riak.Protocol.MapEntry.MapEntry (Maybe ByteString) where + {-# INLINE register_value #-} + register_value f_aiEI (Network.Riak.Protocol.MapEntry.MapEntry x_aiEJ x_aiEK x_aiEL x_aiEM x_aiEN x_aiEO) + = fmap (\ y_aiEP -> Network.Riak.Protocol.MapEntry.MapEntry x_aiEJ x_aiEK x_aiEL y_aiEP x_aiEN x_aiEO) (f_aiEI x_aiEM) +instance HasSetValue Network.Riak.Protocol.MapEntry.MapEntry (Seq ByteString) where + {-# INLINE set_value #-} + set_value f_aiEQ (Network.Riak.Protocol.MapEntry.MapEntry x_aiER x_aiES x_aiET x_aiEU x_aiEV x_aiEW) + = fmap (\ y_aiEX -> Network.Riak.Protocol.MapEntry.MapEntry x_aiER x_aiES y_aiEX x_aiEU x_aiEV x_aiEW) (f_aiEQ x_aiET) +instance HasName Network.Riak.Protocol.MapField.MapField ByteString where + {-# INLINE name #-} + name f_aiHH (Network.Riak.Protocol.MapField.MapField x_aiHI x_aiHJ) + = fmap (\ y_aiHK -> Network.Riak.Protocol.MapField.MapField y_aiHK x_aiHJ) (f_aiHH x_aiHI) +instance HasType' Network.Riak.Protocol.MapField.MapField Network.Riak.Protocol.MapField.MapFieldType.MapFieldType where + {-# INLINE type' #-} + type' f_aiHL (Network.Riak.Protocol.MapField.MapField x_aiHM x_aiHN) + = fmap (\ y_aiHO -> Network.Riak.Protocol.MapField.MapField x_aiHM y_aiHO) (f_aiHL x_aiHN) +class HasRemoves s a | s -> a where + removes :: Lens' s a +instance HasRemoves Network.Riak.Protocol.MapOp.MapOp (Seq Network.Riak.Protocol.MapField.MapField) where + {-# INLINE removes #-} + removes f_aiIv (Network.Riak.Protocol.MapOp.MapOp x_aiIw x_aiIx) + = fmap (\ y_aiIy -> Network.Riak.Protocol.MapOp.MapOp y_aiIy x_aiIx) (f_aiIv x_aiIw) +class HasUpdates s a | s -> a where + updates :: Lens' s a +instance HasUpdates Network.Riak.Protocol.MapOp.MapOp (Seq Network.Riak.Protocol.MapUpdate.MapUpdate) where + {-# INLINE updates #-} + updates f_aiIz (Network.Riak.Protocol.MapOp.MapOp x_aiIA x_aiIB) + = fmap (\ y_aiIC -> Network.Riak.Protocol.MapOp.MapOp x_aiIA y_aiIC) (f_aiIz x_aiIB) +instance HasDone Network.Riak.Protocol.MapReduce.MapReduce (Maybe Bool) where + {-# INLINE done #-} + done f_aiK2 (Network.Riak.Protocol.MapReduce.MapReduce x_aiK3 x_aiK4 x_aiK5) + = fmap (\ y_aiK6 -> Network.Riak.Protocol.MapReduce.MapReduce x_aiK3 x_aiK4 y_aiK6) (f_aiK2 x_aiK5) +class HasPhase s a | s -> a where + phase :: Lens' s a +instance HasPhase Network.Riak.Protocol.MapReduce.MapReduce (Maybe Word32) where + {-# INLINE phase #-} + phase f_aiK7 (Network.Riak.Protocol.MapReduce.MapReduce x_aiK8 x_aiK9 x_aiKa) + = fmap (\ y_aiKb -> Network.Riak.Protocol.MapReduce.MapReduce y_aiKb x_aiK9 x_aiKa) (f_aiK7 x_aiK8) +class HasResponse s a | s -> a where + response :: Lens' s a +instance HasResponse Network.Riak.Protocol.MapReduce.MapReduce (Maybe ByteString) where + {-# INLINE response #-} + response f_aiKc (Network.Riak.Protocol.MapReduce.MapReduce x_aiKd x_aiKe x_aiKf) + = fmap (\ y_aiKg -> Network.Riak.Protocol.MapReduce.MapReduce x_aiKd y_aiKg x_aiKf) (f_aiKc x_aiKe) +instance HasContentType Network.Riak.Protocol.MapReduceRequest.MapReduceRequest ByteString where + {-# INLINE content_type #-} + content_type f_aiLU (Network.Riak.Protocol.MapReduceRequest.MapReduceRequest x_aiLV x_aiLW) + = fmap (\ y_aiLX -> Network.Riak.Protocol.MapReduceRequest.MapReduceRequest x_aiLV y_aiLX) (f_aiLU x_aiLW) +class HasRequest s a | s -> a where + request :: Lens' s a +instance HasRequest Network.Riak.Protocol.MapReduceRequest.MapReduceRequest ByteString where + {-# INLINE request #-} + request f_aiLY (Network.Riak.Protocol.MapReduceRequest.MapReduceRequest x_aiLZ x_aiM0) + = fmap (\ y_aiM1 -> Network.Riak.Protocol.MapReduceRequest.MapReduceRequest y_aiM1 x_aiM0) (f_aiLY x_aiLZ) +instance HasCounterOp Network.Riak.Protocol.MapUpdate.MapUpdate (Maybe Network.Riak.Protocol.CounterOp.CounterOp) where + {-# INLINE counter_op #-} + counter_op f_aiN1 (Network.Riak.Protocol.MapUpdate.MapUpdate x_aiN2 x_aiN3 x_aiN4 x_aiN5 x_aiN6 x_aiN7) + = fmap (\ y_aiN8 -> Network.Riak.Protocol.MapUpdate.MapUpdate x_aiN2 y_aiN8 x_aiN4 x_aiN5 x_aiN6 x_aiN7) (f_aiN1 x_aiN3) +instance HasField Network.Riak.Protocol.MapUpdate.MapUpdate Network.Riak.Protocol.MapField.MapField where + {-# INLINE field #-} + field f_aiN9 (Network.Riak.Protocol.MapUpdate.MapUpdate x_aiNa x_aiNb x_aiNc x_aiNd x_aiNe x_aiNf) + = fmap (\ y_aiNg -> Network.Riak.Protocol.MapUpdate.MapUpdate y_aiNg x_aiNb x_aiNc x_aiNd x_aiNe x_aiNf) (f_aiN9 x_aiNa) +class HasFlagOp s a | s -> a where + flag_op :: Lens' s a +instance HasFlagOp Network.Riak.Protocol.MapUpdate.MapUpdate (Maybe Network.Riak.Protocol.MapUpdate.FlagOp.FlagOp) where + {-# INLINE flag_op #-} + flag_op f_aiNh (Network.Riak.Protocol.MapUpdate.MapUpdate x_aiNi x_aiNj x_aiNk x_aiNl x_aiNm x_aiNn) + = fmap (\ y_aiNo -> Network.Riak.Protocol.MapUpdate.MapUpdate x_aiNi x_aiNj x_aiNk x_aiNl y_aiNo x_aiNn) (f_aiNh x_aiNm) +instance HasMapOp Network.Riak.Protocol.MapUpdate.MapUpdate (Maybe Network.Riak.Protocol.MapOp.MapOp) where + {-# INLINE map_op #-} + map_op f_aiNp (Network.Riak.Protocol.MapUpdate.MapUpdate x_aiNq x_aiNr x_aiNs x_aiNt x_aiNu x_aiNv) + = fmap (\ y_aiNw -> Network.Riak.Protocol.MapUpdate.MapUpdate x_aiNq x_aiNr x_aiNs x_aiNt x_aiNu y_aiNw) (f_aiNp x_aiNv) +class HasRegisterOp s a | s -> a where + register_op :: Lens' s a +instance HasRegisterOp Network.Riak.Protocol.MapUpdate.MapUpdate (Maybe ByteString) where + {-# INLINE register_op #-} + register_op f_aiNx (Network.Riak.Protocol.MapUpdate.MapUpdate x_aiNy x_aiNz x_aiNA x_aiNB x_aiNC x_aiND) + = fmap (\ y_aiNE -> Network.Riak.Protocol.MapUpdate.MapUpdate x_aiNy x_aiNz x_aiNA y_aiNE x_aiNC x_aiND) (f_aiNx x_aiNB) +instance HasSetOp Network.Riak.Protocol.MapUpdate.MapUpdate (Maybe Network.Riak.Protocol.SetOp.SetOp) where + {-# INLINE set_op #-} + set_op f_aiNF (Network.Riak.Protocol.MapUpdate.MapUpdate x_aiNG x_aiNH x_aiNI x_aiNJ x_aiNK x_aiNL) + = fmap (\ y_aiNM -> Network.Riak.Protocol.MapUpdate.MapUpdate x_aiNG x_aiNH y_aiNM x_aiNJ x_aiNK x_aiNL) (f_aiNF x_aiNI) +class HasFunction s a | s -> a where + function :: Lens' s a +instance HasFunction Network.Riak.Protocol.ModFun.ModFun ByteString where + {-# INLINE function #-} + function f_aiQd (Network.Riak.Protocol.ModFun.ModFun x_aiQe x_aiQf) + = fmap (\ y_aiQg -> Network.Riak.Protocol.ModFun.ModFun x_aiQe y_aiQg) (f_aiQd x_aiQf) +class HasModule' s a | s -> a where + module' :: Lens' s a +instance HasModule' Network.Riak.Protocol.ModFun.ModFun ByteString where + {-# INLINE module' #-} + module' f_aiQh (Network.Riak.Protocol.ModFun.ModFun x_aiQi x_aiQj) + = fmap (\ y_aiQk -> Network.Riak.Protocol.ModFun.ModFun y_aiQk x_aiQj) (f_aiQh x_aiQi) +instance HasKey Network.Riak.Protocol.Pair.Pair ByteString where + {-# INLINE key #-} + key f_aiRK (Network.Riak.Protocol.Pair.Pair x_aiRL x_aiRM) + = fmap (\ y_aiRN -> Network.Riak.Protocol.Pair.Pair y_aiRN x_aiRM) (f_aiRK x_aiRL) +instance HasValue Network.Riak.Protocol.Pair.Pair (Maybe ByteString) where + {-# INLINE value #-} + value f_aiRO (Network.Riak.Protocol.Pair.Pair x_aiRP x_aiRQ) + = fmap (\ y_aiRR -> Network.Riak.Protocol.Pair.Pair x_aiRP y_aiRR) (f_aiRO x_aiRQ) +class HasAsis s a | s -> a where + asis :: Lens' s a +instance HasAsis Network.Riak.Protocol.PutRequest.PutRequest (Maybe Bool) where + {-# INLINE asis #-} + asis + f_aiSy + (Network.Riak.Protocol.PutRequest.PutRequest x_aiSz + x_aiSA + x_aiSB + x_aiSC + x_aiSD + x_aiSE + x_aiSF + x_aiSG + x_aiSH + x_aiSI + x_aiSJ + x_aiSK + x_aiSL + x_aiSM + x_aiSN + x_aiSO) + = fmap + (\ y_aiSP + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiSz x_aiSA x_aiSB x_aiSC x_aiSD x_aiSE x_aiSF x_aiSG x_aiSH x_aiSI x_aiSJ x_aiSK y_aiSP x_aiSM x_aiSN x_aiSO) + (f_aiSy x_aiSL) +instance HasBucket Network.Riak.Protocol.PutRequest.PutRequest ByteString where + {-# INLINE bucket #-} + bucket + f_aiSQ + (Network.Riak.Protocol.PutRequest.PutRequest x_aiSR + x_aiSS + x_aiST + x_aiSU + x_aiSV + x_aiSW + x_aiSX + x_aiSY + x_aiSZ + x_aiT0 + x_aiT1 + x_aiT2 + x_aiT3 + x_aiT4 + x_aiT5 + x_aiT6) + = fmap + (\ y_aiT7 + -> Network.Riak.Protocol.PutRequest.PutRequest + y_aiT7 x_aiSS x_aiST x_aiSU x_aiSV x_aiSW x_aiSX x_aiSY x_aiSZ x_aiT0 x_aiT1 x_aiT2 x_aiT3 x_aiT4 x_aiT5 x_aiT6) + (f_aiSQ x_aiSR) +instance HasContent Network.Riak.Protocol.PutRequest.PutRequest Network.Riak.Protocol.Content.Content where + {-# INLINE content #-} + content + f_aiT8 + (Network.Riak.Protocol.PutRequest.PutRequest x_aiT9 + x_aiTa + x_aiTb + x_aiTc + x_aiTd + x_aiTe + x_aiTf + x_aiTg + x_aiTh + x_aiTi + x_aiTj + x_aiTk + x_aiTl + x_aiTm + x_aiTn + x_aiTo) + = fmap + (\ y_aiTp + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiT9 x_aiTa x_aiTb y_aiTp x_aiTd x_aiTe x_aiTf x_aiTg x_aiTh x_aiTi x_aiTj x_aiTk x_aiTl x_aiTm x_aiTn x_aiTo) + (f_aiT8 x_aiTc) +instance HasDw Network.Riak.Protocol.PutRequest.PutRequest (Maybe Word32) where + {-# INLINE dw #-} + dw + f_aiTq + (Network.Riak.Protocol.PutRequest.PutRequest x_aiTr + x_aiTs + x_aiTt + x_aiTu + x_aiTv + x_aiTw + x_aiTx + x_aiTy + x_aiTz + x_aiTA + x_aiTB + x_aiTC + x_aiTD + x_aiTE + x_aiTF + x_aiTG) + = fmap + (\ y_aiTH + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiTr x_aiTs x_aiTt x_aiTu x_aiTv y_aiTH x_aiTx x_aiTy x_aiTz x_aiTA x_aiTB x_aiTC x_aiTD x_aiTE x_aiTF x_aiTG) + (f_aiTq x_aiTw) +class HasIfNoneMatch s a | s -> a where + if_none_match :: Lens' s a +instance HasIfNoneMatch Network.Riak.Protocol.PutRequest.PutRequest (Maybe Bool) where + {-# INLINE if_none_match #-} + if_none_match + f_aiTI + (Network.Riak.Protocol.PutRequest.PutRequest x_aiTJ + x_aiTK + x_aiTL + x_aiTM + x_aiTN + x_aiTO + x_aiTP + x_aiTQ + x_aiTR + x_aiTS + x_aiTT + x_aiTU + x_aiTV + x_aiTW + x_aiTX + x_aiTY) + = fmap + (\ y_aiTZ + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiTJ x_aiTK x_aiTL x_aiTM x_aiTN x_aiTO x_aiTP x_aiTQ x_aiTR y_aiTZ x_aiTT x_aiTU x_aiTV x_aiTW x_aiTX x_aiTY) + (f_aiTI x_aiTS) +class HasIfNotModified s a | s -> a where + if_not_modified :: Lens' s a +instance HasIfNotModified Network.Riak.Protocol.PutRequest.PutRequest (Maybe Bool) where + {-# INLINE if_not_modified #-} + if_not_modified + f_aiU0 + (Network.Riak.Protocol.PutRequest.PutRequest x_aiU1 + x_aiU2 + x_aiU3 + x_aiU4 + x_aiU5 + x_aiU6 + x_aiU7 + x_aiU8 + x_aiU9 + x_aiUa + x_aiUb + x_aiUc + x_aiUd + x_aiUe + x_aiUf + x_aiUg) + = fmap + (\ y_aiUh + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiU1 x_aiU2 x_aiU3 x_aiU4 x_aiU5 x_aiU6 x_aiU7 x_aiU8 y_aiUh x_aiUa x_aiUb x_aiUc x_aiUd x_aiUe x_aiUf x_aiUg) + (f_aiU0 x_aiU9) +instance HasKey Network.Riak.Protocol.PutRequest.PutRequest (Maybe ByteString) where + {-# INLINE key #-} + key + f_aiUi + (Network.Riak.Protocol.PutRequest.PutRequest x_aiUj + x_aiUk + x_aiUl + x_aiUm + x_aiUn + x_aiUo + x_aiUp + x_aiUq + x_aiUr + x_aiUs + x_aiUt + x_aiUu + x_aiUv + x_aiUw + x_aiUx + x_aiUy) + = fmap + (\ y_aiUz + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiUj y_aiUz x_aiUl x_aiUm x_aiUn x_aiUo x_aiUp x_aiUq x_aiUr x_aiUs x_aiUt x_aiUu x_aiUv x_aiUw x_aiUx x_aiUy) + (f_aiUi x_aiUk) +instance HasNVal Network.Riak.Protocol.PutRequest.PutRequest (Maybe Word32) where + {-# INLINE n_val #-} + n_val + f_aiUA + (Network.Riak.Protocol.PutRequest.PutRequest x_aiUB + x_aiUC + x_aiUD + x_aiUE + x_aiUF + x_aiUG + x_aiUH + x_aiUI + x_aiUJ + x_aiUK + x_aiUL + x_aiUM + x_aiUN + x_aiUO + x_aiUP + x_aiUQ) + = fmap + (\ y_aiUR + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiUB x_aiUC x_aiUD x_aiUE x_aiUF x_aiUG x_aiUH x_aiUI x_aiUJ x_aiUK x_aiUL x_aiUM x_aiUN x_aiUO y_aiUR x_aiUQ) + (f_aiUA x_aiUP) +instance HasPw Network.Riak.Protocol.PutRequest.PutRequest (Maybe Word32) where + {-# INLINE pw #-} + pw + f_aiUS + (Network.Riak.Protocol.PutRequest.PutRequest x_aiUT + x_aiUU + x_aiUV + x_aiUW + x_aiUX + x_aiUY + x_aiUZ + x_aiV0 + x_aiV1 + x_aiV2 + x_aiV3 + x_aiV4 + x_aiV5 + x_aiV6 + x_aiV7 + x_aiV8) + = fmap + (\ y_aiV9 + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiUT x_aiUU x_aiUV x_aiUW x_aiUX x_aiUY x_aiUZ y_aiV9 x_aiV1 x_aiV2 x_aiV3 x_aiV4 x_aiV5 x_aiV6 x_aiV7 x_aiV8) + (f_aiUS x_aiV0) +instance HasReturnBody Network.Riak.Protocol.PutRequest.PutRequest (Maybe Bool) where + {-# INLINE return_body #-} + return_body + f_aiVa + (Network.Riak.Protocol.PutRequest.PutRequest x_aiVb + x_aiVc + x_aiVd + x_aiVe + x_aiVf + x_aiVg + x_aiVh + x_aiVi + x_aiVj + x_aiVk + x_aiVl + x_aiVm + x_aiVn + x_aiVo + x_aiVp + x_aiVq) + = fmap + (\ y_aiVr + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiVb x_aiVc x_aiVd x_aiVe x_aiVf x_aiVg y_aiVr x_aiVi x_aiVj x_aiVk x_aiVl x_aiVm x_aiVn x_aiVo x_aiVp x_aiVq) + (f_aiVa x_aiVh) +class HasReturnHead s a | s -> a where + return_head :: Lens' s a +instance HasReturnHead Network.Riak.Protocol.PutRequest.PutRequest (Maybe Bool) where + {-# INLINE return_head #-} + return_head + f_aiVs + (Network.Riak.Protocol.PutRequest.PutRequest x_aiVt + x_aiVu + x_aiVv + x_aiVw + x_aiVx + x_aiVy + x_aiVz + x_aiVA + x_aiVB + x_aiVC + x_aiVD + x_aiVE + x_aiVF + x_aiVG + x_aiVH + x_aiVI) + = fmap + (\ y_aiVJ + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiVt x_aiVu x_aiVv x_aiVw x_aiVx x_aiVy x_aiVz x_aiVA x_aiVB x_aiVC y_aiVJ x_aiVE x_aiVF x_aiVG x_aiVH x_aiVI) + (f_aiVs x_aiVD) +instance HasSloppyQuorum Network.Riak.Protocol.PutRequest.PutRequest (Maybe Bool) where + {-# INLINE sloppy_quorum #-} + sloppy_quorum + f_aiVK + (Network.Riak.Protocol.PutRequest.PutRequest x_aiVL + x_aiVM + x_aiVN + x_aiVO + x_aiVP + x_aiVQ + x_aiVR + x_aiVS + x_aiVT + x_aiVU + x_aiVV + x_aiVW + x_aiVX + x_aiVY + x_aiVZ + x_aiW0) + = fmap + (\ y_aiW1 + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiVL x_aiVM x_aiVN x_aiVO x_aiVP x_aiVQ x_aiVR x_aiVS x_aiVT x_aiVU x_aiVV x_aiVW x_aiVX y_aiW1 x_aiVZ x_aiW0) + (f_aiVK x_aiVY) +instance HasTimeout Network.Riak.Protocol.PutRequest.PutRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout + f_aiW2 + (Network.Riak.Protocol.PutRequest.PutRequest x_aiW3 + x_aiW4 + x_aiW5 + x_aiW6 + x_aiW7 + x_aiW8 + x_aiW9 + x_aiWa + x_aiWb + x_aiWc + x_aiWd + x_aiWe + x_aiWf + x_aiWg + x_aiWh + x_aiWi) + = fmap + (\ y_aiWj + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiW3 x_aiW4 x_aiW5 x_aiW6 x_aiW7 x_aiW8 x_aiW9 x_aiWa x_aiWb x_aiWc x_aiWd y_aiWj x_aiWf x_aiWg x_aiWh x_aiWi) + (f_aiW2 x_aiWe) +instance HasType' Network.Riak.Protocol.PutRequest.PutRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' + f_aiWk + (Network.Riak.Protocol.PutRequest.PutRequest x_aiWl + x_aiWm + x_aiWn + x_aiWo + x_aiWp + x_aiWq + x_aiWr + x_aiWs + x_aiWt + x_aiWu + x_aiWv + x_aiWw + x_aiWx + x_aiWy + x_aiWz + x_aiWA) + = fmap + (\ y_aiWB + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiWl x_aiWm x_aiWn x_aiWo x_aiWp x_aiWq x_aiWr x_aiWs x_aiWt x_aiWu x_aiWv x_aiWw x_aiWx x_aiWy x_aiWz y_aiWB) + (f_aiWk x_aiWA) +instance HasVclock Network.Riak.Protocol.PutRequest.PutRequest (Maybe ByteString) where + {-# INLINE vclock #-} + vclock + f_aiWC + (Network.Riak.Protocol.PutRequest.PutRequest x_aiWD + x_aiWE + x_aiWF + x_aiWG + x_aiWH + x_aiWI + x_aiWJ + x_aiWK + x_aiWL + x_aiWM + x_aiWN + x_aiWO + x_aiWP + x_aiWQ + x_aiWR + x_aiWS) + = fmap + (\ y_aiWT + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiWD x_aiWE y_aiWT x_aiWG x_aiWH x_aiWI x_aiWJ x_aiWK x_aiWL x_aiWM x_aiWN x_aiWO x_aiWP x_aiWQ x_aiWR x_aiWS) + (f_aiWC x_aiWF) +instance HasW Network.Riak.Protocol.PutRequest.PutRequest (Maybe Word32) where + {-# INLINE w #-} + w f_aiWU + (Network.Riak.Protocol.PutRequest.PutRequest x_aiWV + x_aiWW + x_aiWX + x_aiWY + x_aiWZ + x_aiX0 + x_aiX1 + x_aiX2 + x_aiX3 + x_aiX4 + x_aiX5 + x_aiX6 + x_aiX7 + x_aiX8 + x_aiX9 + x_aiXa) + = fmap + (\ y_aiXb + -> Network.Riak.Protocol.PutRequest.PutRequest + x_aiWV x_aiWW x_aiWX x_aiWY y_aiXb x_aiX0 x_aiX1 x_aiX2 x_aiX3 x_aiX4 x_aiX5 x_aiX6 x_aiX7 x_aiX8 x_aiX9 x_aiXa) + (f_aiWU x_aiWZ) +instance HasContent Network.Riak.Protocol.PutResponse.PutResponse (Seq Network.Riak.Protocol.Content.Content) where + {-# INLINE content #-} + content f_aj2B (Network.Riak.Protocol.PutResponse.PutResponse x_aj2C x_aj2D x_aj2E) + = fmap (\ y_aj2F -> Network.Riak.Protocol.PutResponse.PutResponse y_aj2F x_aj2D x_aj2E) (f_aj2B x_aj2C) +instance HasKey Network.Riak.Protocol.PutResponse.PutResponse (Maybe ByteString) where + {-# INLINE key #-} + key f_aj2G (Network.Riak.Protocol.PutResponse.PutResponse x_aj2H x_aj2I x_aj2J) + = fmap (\ y_aj2K -> Network.Riak.Protocol.PutResponse.PutResponse x_aj2H x_aj2I y_aj2K) (f_aj2G x_aj2J) +instance HasVclock Network.Riak.Protocol.PutResponse.PutResponse (Maybe ByteString) where + {-# INLINE vclock #-} + vclock f_aj2L (Network.Riak.Protocol.PutResponse.PutResponse x_aj2M x_aj2N x_aj2O) + = fmap (\ y_aj2P -> Network.Riak.Protocol.PutResponse.PutResponse x_aj2M y_aj2P x_aj2O) (f_aj2L x_aj2N) +instance HasBucket Network.Riak.Protocol.ResetBucketRequest.ResetBucketRequest ByteString where + {-# INLINE bucket #-} + bucket f_aj3D (Network.Riak.Protocol.ResetBucketRequest.ResetBucketRequest x_aj3E x_aj3F) + = fmap (\ y_aj3G -> Network.Riak.Protocol.ResetBucketRequest.ResetBucketRequest y_aj3G x_aj3F) (f_aj3D x_aj3E) +instance HasType' Network.Riak.Protocol.ResetBucketRequest.ResetBucketRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' f_aj3H (Network.Riak.Protocol.ResetBucketRequest.ResetBucketRequest x_aj3I x_aj3J) + = fmap (\ y_aj3K -> Network.Riak.Protocol.ResetBucketRequest.ResetBucketRequest x_aj3I y_aj3K) (f_aj3H x_aj3J) +class HasFields s a | s -> a where + fields :: Lens' s a +instance HasFields Network.Riak.Protocol.SearchDoc.SearchDoc (Seq Network.Riak.Protocol.Pair.Pair) where + {-# INLINE fields #-} + fields f_aj4k (Network.Riak.Protocol.SearchDoc.SearchDoc x_aj4l) + = fmap (\ y_aj4m -> Network.Riak.Protocol.SearchDoc.SearchDoc y_aj4m) (f_aj4k x_aj4l) +class HasDf s a | s -> a where + df :: Lens' s a +instance HasDf Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest (Maybe ByteString) where + {-# INLINE df #-} + df + f_aj58 + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj59 x_aj5a x_aj5b x_aj5c x_aj5d x_aj5e x_aj5f x_aj5g x_aj5h x_aj5i) + = fmap + (\ y_aj5j + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj59 x_aj5a x_aj5b x_aj5c x_aj5d x_aj5e y_aj5j x_aj5g x_aj5h x_aj5i) + (f_aj58 x_aj5f) +class HasFilter s a | s -> a where + filter :: Lens' s a +instance HasFilter Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest (Maybe ByteString) where + {-# INLINE filter #-} + filter + f_aj5k + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj5l x_aj5m x_aj5n x_aj5o x_aj5p x_aj5q x_aj5r x_aj5s x_aj5t x_aj5u) + = fmap + (\ y_aj5v + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj5l x_aj5m x_aj5n x_aj5o x_aj5p y_aj5v x_aj5r x_aj5s x_aj5t x_aj5u) + (f_aj5k x_aj5q) +class HasFl s a | s -> a where + fl :: Lens' s a +instance HasFl Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest (Seq ByteString) where + {-# INLINE fl #-} + fl + f_aj5w + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj5x x_aj5y x_aj5z x_aj5A x_aj5B x_aj5C x_aj5D x_aj5E x_aj5F x_aj5G) + = fmap + (\ y_aj5H + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj5x x_aj5y x_aj5z x_aj5A x_aj5B x_aj5C x_aj5D x_aj5E y_aj5H x_aj5G) + (f_aj5w x_aj5F) +instance HasIndex Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest ByteString where + {-# INLINE index #-} + index + f_aj5I + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj5J x_aj5K x_aj5L x_aj5M x_aj5N x_aj5O x_aj5P x_aj5Q x_aj5R x_aj5S) + = fmap + (\ y_aj5T + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj5J y_aj5T x_aj5L x_aj5M x_aj5N x_aj5O x_aj5P x_aj5Q x_aj5R x_aj5S) + (f_aj5I x_aj5K) +instance HasOp Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest (Maybe ByteString) where + {-# INLINE op #-} + op + f_aj5U + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj5V x_aj5W x_aj5X x_aj5Y x_aj5Z x_aj60 x_aj61 x_aj62 x_aj63 x_aj64) + = fmap + (\ y_aj65 + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj5V x_aj5W x_aj5X x_aj5Y x_aj5Z x_aj60 x_aj61 y_aj65 x_aj63 x_aj64) + (f_aj5U x_aj62) +class HasPresort s a | s -> a where + presort :: Lens' s a +instance HasPresort Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest (Maybe ByteString) where + {-# INLINE presort #-} + presort + f_aj66 + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj67 x_aj68 x_aj69 x_aj6a x_aj6b x_aj6c x_aj6d x_aj6e x_aj6f x_aj6g) + = fmap + (\ y_aj6h + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj67 x_aj68 x_aj69 x_aj6a x_aj6b x_aj6c x_aj6d x_aj6e x_aj6f y_aj6h) + (f_aj66 x_aj6g) +class HasQ s a | s -> a where + q :: Lens' s a +instance HasQ Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest ByteString where + {-# INLINE q #-} + q f_aj6i + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj6j x_aj6k x_aj6l x_aj6m x_aj6n x_aj6o x_aj6p x_aj6q x_aj6r x_aj6s) + = fmap + (\ y_aj6t + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest y_aj6t x_aj6k x_aj6l x_aj6m x_aj6n x_aj6o x_aj6p x_aj6q x_aj6r x_aj6s) + (f_aj6i x_aj6j) +class HasRows s a | s -> a where + rows :: Lens' s a +instance HasRows Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest (Maybe Word32) where + {-# INLINE rows #-} + rows + f_aj6u + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj6v x_aj6w x_aj6x x_aj6y x_aj6z x_aj6A x_aj6B x_aj6C x_aj6D x_aj6E) + = fmap + (\ y_aj6F + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj6v x_aj6w y_aj6F x_aj6y x_aj6z x_aj6A x_aj6B x_aj6C x_aj6D x_aj6E) + (f_aj6u x_aj6x) +class HasSort s a | s -> a where + sort :: Lens' s a +instance HasSort Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest (Maybe ByteString) where + {-# INLINE sort #-} + sort + f_aj6G + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj6H x_aj6I x_aj6J x_aj6K x_aj6L x_aj6M x_aj6N x_aj6O x_aj6P x_aj6Q) + = fmap + (\ y_aj6R + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj6H x_aj6I x_aj6J x_aj6K y_aj6R x_aj6M x_aj6N x_aj6O x_aj6P x_aj6Q) + (f_aj6G x_aj6L) +class HasStart s a | s -> a where + start :: Lens' s a +instance HasStart Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest (Maybe Word32) where + {-# INLINE start #-} + start + f_aj6S + (Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj6T x_aj6U x_aj6V x_aj6W x_aj6X x_aj6Y x_aj6Z x_aj70 x_aj71 x_aj72) + = fmap + (\ y_aj73 + -> Network.Riak.Protocol.SearchQueryRequest.SearchQueryRequest x_aj6T x_aj6U x_aj6V y_aj73 x_aj6X x_aj6Y x_aj6Z x_aj70 x_aj71 x_aj72) + (f_aj6S x_aj6W) +class HasDocs s a | s -> a where + docs :: Lens' s a +instance HasDocs Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse (Seq Network.Riak.Protocol.SearchDoc.SearchDoc) where + {-# INLINE docs #-} + docs f_ajcN (Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse x_ajcO x_ajcP x_ajcQ) + = fmap (\ y_ajcR -> Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse y_ajcR x_ajcP x_ajcQ) (f_ajcN x_ajcO) +class HasMaxScore s a | s -> a where + max_score :: Lens' s a +instance HasMaxScore Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse (Maybe Float) where + {-# INLINE max_score #-} + max_score f_ajcS (Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse x_ajcT x_ajcU x_ajcV) + = fmap (\ y_ajcW -> Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse x_ajcT y_ajcW x_ajcV) (f_ajcS x_ajcU) +class HasNumFound s a | s -> a where + num_found :: Lens' s a +instance HasNumFound Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse (Maybe Word32) where + {-# INLINE num_found #-} + num_found f_ajcX (Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse x_ajcY x_ajcZ x_ajd0) + = fmap (\ y_ajd1 -> Network.Riak.Protocol.SearchQueryResponse.SearchQueryResponse x_ajcY x_ajcZ y_ajd1) (f_ajcX x_ajd0) +instance HasNode Network.Riak.Protocol.ServerInfo.ServerInfo (Maybe ByteString) where + {-# INLINE node #-} + node f_ajf5 (Network.Riak.Protocol.ServerInfo.ServerInfo x_ajf6 x_ajf7) + = fmap (\ y_ajf8 -> Network.Riak.Protocol.ServerInfo.ServerInfo y_ajf8 x_ajf7) (f_ajf5 x_ajf6) +class HasServerVersion s a | s -> a where + server_version :: Lens' s a +instance HasServerVersion Network.Riak.Protocol.ServerInfo.ServerInfo (Maybe ByteString) where + {-# INLINE server_version #-} + server_version f_ajf9 (Network.Riak.Protocol.ServerInfo.ServerInfo x_ajfa x_ajfb) + = fmap (\ y_ajfc -> Network.Riak.Protocol.ServerInfo.ServerInfo x_ajfa y_ajfc) (f_ajf9 x_ajfb) +instance HasBucket Network.Riak.Protocol.SetBucketRequest.SetBucketRequest ByteString where + {-# INLINE bucket #-} + bucket f_ajgc (Network.Riak.Protocol.SetBucketRequest.SetBucketRequest x_ajgd x_ajge x_ajgf) + = fmap (\ y_ajgg -> Network.Riak.Protocol.SetBucketRequest.SetBucketRequest y_ajgg x_ajge x_ajgf) (f_ajgc x_ajgd) +instance HasProps Network.Riak.Protocol.SetBucketRequest.SetBucketRequest Network.Riak.Protocol.BucketProps.BucketProps where + {-# INLINE props #-} + props f_ajgh (Network.Riak.Protocol.SetBucketRequest.SetBucketRequest x_ajgi x_ajgj x_ajgk) + = fmap (\ y_ajgl -> Network.Riak.Protocol.SetBucketRequest.SetBucketRequest x_ajgi y_ajgl x_ajgk) (f_ajgh x_ajgj) +instance HasType' Network.Riak.Protocol.SetBucketRequest.SetBucketRequest (Maybe ByteString) where + {-# INLINE type' #-} + type' f_ajgm (Network.Riak.Protocol.SetBucketRequest.SetBucketRequest x_ajgn x_ajgo x_ajgp) + = fmap (\ y_ajgq -> Network.Riak.Protocol.SetBucketRequest.SetBucketRequest x_ajgn x_ajgo y_ajgq) (f_ajgm x_ajgp) +instance HasProps Network.Riak.Protocol.SetBucketTypeRequest.SetBucketTypeRequest Network.Riak.Protocol.BucketProps.BucketProps where + {-# INLINE props #-} + props f_ajhe (Network.Riak.Protocol.SetBucketTypeRequest.SetBucketTypeRequest x_ajhf x_ajhg) + = fmap (\ y_ajhh -> Network.Riak.Protocol.SetBucketTypeRequest.SetBucketTypeRequest x_ajhf y_ajhh) (f_ajhe x_ajhg) +instance HasType' Network.Riak.Protocol.SetBucketTypeRequest.SetBucketTypeRequest ByteString where + {-# INLINE type' #-} + type' f_ajhi (Network.Riak.Protocol.SetBucketTypeRequest.SetBucketTypeRequest x_ajhj x_ajhk) + = fmap (\ y_ajhl -> Network.Riak.Protocol.SetBucketTypeRequest.SetBucketTypeRequest y_ajhl x_ajhk) (f_ajhi x_ajhj) +instance HasClientId Network.Riak.Protocol.SetClientIDRequest.SetClientIDRequest ByteString where + {-# INLINE client_id #-} + client_id f_ajhV (Network.Riak.Protocol.SetClientIDRequest.SetClientIDRequest x_ajhW) + = fmap (\ y_ajhX -> Network.Riak.Protocol.SetClientIDRequest.SetClientIDRequest y_ajhX) (f_ajhV x_ajhW) +class HasAdds s a | s -> a where + adds :: Lens' s a +instance HasAdds Network.Riak.Protocol.SetOp.SetOp (Seq ByteString) where + {-# INLINE adds #-} + adds f_ajij (Network.Riak.Protocol.SetOp.SetOp x_ajik x_ajil) + = fmap (\ y_ajim -> Network.Riak.Protocol.SetOp.SetOp y_ajim x_ajil) (f_ajij x_ajik) +instance HasRemoves Network.Riak.Protocol.SetOp.SetOp (Seq ByteString) where + {-# INLINE removes #-} + removes f_ajin (Network.Riak.Protocol.SetOp.SetOp x_ajio x_ajip) + = fmap (\ y_ajiq -> Network.Riak.Protocol.SetOp.SetOp x_ajio y_ajiq) (f_ajin x_ajip) +instance HasNVal Network.Riak.Protocol.YzIndex.YzIndex (Maybe Word32) where + {-# INLINE n_val #-} + n_val f_ajjq (Network.Riak.Protocol.YzIndex.YzIndex x_ajjr x_ajjs x_ajjt) + = fmap (\ y_ajju -> Network.Riak.Protocol.YzIndex.YzIndex x_ajjr x_ajjs y_ajju) (f_ajjq x_ajjt) +instance HasName Network.Riak.Protocol.YzIndex.YzIndex ByteString where + {-# INLINE name #-} + name f_ajjv (Network.Riak.Protocol.YzIndex.YzIndex x_ajjw x_ajjx x_ajjy) + = fmap (\ y_ajjz -> Network.Riak.Protocol.YzIndex.YzIndex y_ajjz x_ajjx x_ajjy) (f_ajjv x_ajjw) +class HasSchema s a | s -> a where + schema :: Lens' s a +instance HasSchema Network.Riak.Protocol.YzIndex.YzIndex (Maybe ByteString) where + {-# INLINE schema #-} + schema f_ajjA (Network.Riak.Protocol.YzIndex.YzIndex x_ajjB x_ajjC x_ajjD) + = fmap (\ y_ajjE -> Network.Riak.Protocol.YzIndex.YzIndex x_ajjB y_ajjE x_ajjD) (f_ajjA x_ajjC) +instance HasName Network.Riak.Protocol.YzIndexDeleteRequest.YzIndexDeleteRequest ByteString where + {-# INLINE name #-} + name f_ajkS (Network.Riak.Protocol.YzIndexDeleteRequest.YzIndexDeleteRequest x_ajkT) + = fmap (\ y_ajkU -> Network.Riak.Protocol.YzIndexDeleteRequest.YzIndexDeleteRequest y_ajkU) (f_ajkS x_ajkT) +instance HasName Network.Riak.Protocol.YzIndexGetRequest.YzIndexGetRequest (Maybe ByteString) where + {-# INLINE name #-} + name f_ajlg (Network.Riak.Protocol.YzIndexGetRequest.YzIndexGetRequest x_ajlh) + = fmap (\ y_ajli -> Network.Riak.Protocol.YzIndexGetRequest.YzIndexGetRequest y_ajli) (f_ajlg x_ajlh) +instance HasIndex Network.Riak.Protocol.YzIndexGetResponse.YzIndexGetResponse (Seq Network.Riak.Protocol.YzIndex.YzIndex) where + {-# INLINE index #-} + index f_ajlE (Network.Riak.Protocol.YzIndexGetResponse.YzIndexGetResponse x_ajlF) + = fmap (\ y_ajlG -> Network.Riak.Protocol.YzIndexGetResponse.YzIndexGetResponse y_ajlG) (f_ajlE x_ajlF) +instance HasIndex Network.Riak.Protocol.YzIndexPutRequest.YzIndexPutRequest Network.Riak.Protocol.YzIndex.YzIndex where + {-# INLINE index #-} + index f_ajm2 (Network.Riak.Protocol.YzIndexPutRequest.YzIndexPutRequest x_ajm3 x_ajm4) + = fmap (\ y_ajm5 -> Network.Riak.Protocol.YzIndexPutRequest.YzIndexPutRequest y_ajm5 x_ajm4) (f_ajm2 x_ajm3) +instance HasTimeout Network.Riak.Protocol.YzIndexPutRequest.YzIndexPutRequest (Maybe Word32) where + {-# INLINE timeout #-} + timeout f_ajm6 (Network.Riak.Protocol.YzIndexPutRequest.YzIndexPutRequest x_ajm7 x_ajm8) + = fmap (\ y_ajm9 -> Network.Riak.Protocol.YzIndexPutRequest.YzIndexPutRequest x_ajm7 y_ajm9) (f_ajm6 x_ajm8) +instance HasContent Network.Riak.Protocol.YzSchema.YzSchema (Maybe ByteString) where + {-# INLINE content #-} + content f_ajmL (Network.Riak.Protocol.YzSchema.YzSchema x_ajmM x_ajmN) + = fmap (\ y_ajmO -> Network.Riak.Protocol.YzSchema.YzSchema x_ajmM y_ajmO) (f_ajmL x_ajmN) +instance HasName Network.Riak.Protocol.YzSchema.YzSchema ByteString where + {-# INLINE name #-} + name f_ajmP (Network.Riak.Protocol.YzSchema.YzSchema x_ajmQ x_ajmR) + = fmap (\ y_ajmS -> Network.Riak.Protocol.YzSchema.YzSchema y_ajmS x_ajmR) (f_ajmP x_ajmQ) +instance HasName Network.Riak.Protocol.YzSchemaGetRequest.YzSchemaGetRequest ByteString where + {-# INLINE name #-} + name f_ajns (Network.Riak.Protocol.YzSchemaGetRequest.YzSchemaGetRequest x_ajnt) + = fmap (\ y_ajnu -> Network.Riak.Protocol.YzSchemaGetRequest.YzSchemaGetRequest y_ajnu) (f_ajns x_ajnt) +instance HasSchema Network.Riak.Protocol.YzSchemaGetResponse.YzSchemaGetResponse Network.Riak.Protocol.YzSchema.YzSchema where + {-# INLINE schema #-} + schema f_ajnQ (Network.Riak.Protocol.YzSchemaGetResponse.YzSchemaGetResponse x_ajnR) + = fmap (\ y_ajnS -> Network.Riak.Protocol.YzSchemaGetResponse.YzSchemaGetResponse y_ajnS) (f_ajnQ x_ajnR) +instance HasSchema Network.Riak.Protocol.YzSchemaPutRequest.YzSchemaPutRequest Network.Riak.Protocol.YzSchema.YzSchema where + {-# INLINE schema #-} + schema f_ajoe (Network.Riak.Protocol.YzSchemaPutRequest.YzSchemaPutRequest x_ajof) + = fmap (\ y_ajog -> Network.Riak.Protocol.YzSchemaPutRequest.YzSchemaPutRequest y_ajog) (f_ajoe x_ajof)