diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..56ad05d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +dist* diff --git a/Network/Wreq/Internal/Lens.hs b/Network/Wreq/Internal/Lens.hs index 3742e40..387009a 100644 --- a/Network/Wreq/Internal/Lens.hs +++ b/Network/Wreq/Internal/Lens.hs @@ -39,13 +39,1667 @@ import Control.Lens hiding (makeLenses) import Data.List (partition) import Network.HTTP.Client (Request) import Network.HTTP.Types (HeaderName) -import Network.Wreq.Lens.Machinery (makeLenses) import Network.Wreq.Internal.Types (Session) import qualified Data.ByteString as S import qualified Network.HTTP.Client as HTTP -makeLenses ''HTTP.Request -makeLenses ''Session +import qualified Network.HTTP.Client.Types +import qualified Control.Lens.Type +import qualified Data.ByteString.Internal +import qualified GHC.Base +import qualified GHC.Maybe +import qualified GHC.Types +import qualified Network.HTTP.Types.Header +import qualified Network.Wreq.Internal.Types +import qualified GHC.IORef +import qualified Network.Socket as Network.Socket.Types +import qualified Network.HTTP.Types.Method +import qualified GHC.Exception.Type +import qualified Network.HTTP.Types.Version + +-- Network/Wreq/Internal/Lens.hs:47:1-25: Splicing declarations +checkResponse :: + Control.Lens.Type.Lens' + Network.HTTP.Client.Types.Request + ( Network.HTTP.Client.Types.Request -> + Network.HTTP.Client.Types.Response Network.HTTP.Client.Types.BodyReader -> + GHC.Types.IO () + ) +checkResponse + f_ajCp + ( Network.HTTP.Client.Types.Request + x1_ajCq + x2_ajCr + x3_ajCs + x4_ajCt + x5_ajCu + x6_ajCv + x7_ajCw + x8_ajCx + x9_ajCy + x10_ajCz + x11_ajCA + x12_ajCB + x13_ajCC + x14_ajCD + x15_ajCE + x16_ajCF + x17_ajCG + x18_ajCH + x19_ajCI + x20_ajCJ + x21_ajCK + ) = + ( GHC.Base.fmap + ( \y1_ajCL -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajCq) + x2_ajCr + ) + x3_ajCs + ) + x4_ajCt + ) + x5_ajCu + ) + x6_ajCv + ) + x7_ajCw + ) + x8_ajCx + ) + x9_ajCy + ) + x10_ajCz + ) + x11_ajCA + ) + x12_ajCB + ) + x13_ajCC + ) + y1_ajCL + ) + x15_ajCE + ) + x16_ajCF + ) + x17_ajCG + ) + x18_ajCH + ) + x19_ajCI + ) + x20_ajCJ + ) + x21_ajCK + ) + ) + (f_ajCp x14_ajCD) +{-# INLINE checkResponse #-} +cookieJar :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request (GHC.Maybe.Maybe Network.HTTP.Client.Types.CookieJar) +cookieJar + f_ajCM + ( Network.HTTP.Client.Types.Request + x1_ajCN + x2_ajCO + x3_ajCP + x4_ajCQ + x5_ajCR + x6_ajCS + x7_ajCT + x8_ajCU + x9_ajCV + x10_ajCW + x11_ajCX + x12_ajCY + x13_ajCZ + x14_ajD0 + x15_ajD1 + x16_ajD2 + x17_ajD3 + x18_ajD4 + x19_ajD5 + x20_ajD6 + x21_ajD7 + ) = + ( GHC.Base.fmap + ( \y1_ajD8 -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajCN) + x2_ajCO + ) + x3_ajCP + ) + x4_ajCQ + ) + x5_ajCR + ) + x6_ajCS + ) + x7_ajCT + ) + x8_ajCU + ) + x9_ajCV + ) + x10_ajCW + ) + x11_ajCX + ) + x12_ajCY + ) + x13_ajCZ + ) + x14_ajD0 + ) + x15_ajD1 + ) + y1_ajD8 + ) + x17_ajD3 + ) + x18_ajD4 + ) + x19_ajD5 + ) + x20_ajD6 + ) + x21_ajD7 + ) + ) + (f_ajCM x16_ajD2) +{-# INLINE cookieJar #-} +decompress :: + Control.Lens.Type.Lens' + Network.HTTP.Client.Types.Request + ( Data.ByteString.Internal.ByteString -> + GHC.Types.Bool + ) +decompress + f_ajD9 + ( Network.HTTP.Client.Types.Request + x1_ajDa + x2_ajDb + x3_ajDc + x4_ajDd + x5_ajDe + x6_ajDf + x7_ajDg + x8_ajDh + x9_ajDi + x10_ajDj + x11_ajDk + x12_ajDl + x13_ajDm + x14_ajDn + x15_ajDo + x16_ajDp + x17_ajDq + x18_ajDr + x19_ajDs + x20_ajDt + x21_ajDu + ) = + ( GHC.Base.fmap + ( \y1_ajDv -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajDa) + x2_ajDb + ) + x3_ajDc + ) + x4_ajDd + ) + x5_ajDe + ) + x6_ajDf + ) + x7_ajDg + ) + x8_ajDh + ) + x9_ajDi + ) + x10_ajDj + ) + x11_ajDk + ) + y1_ajDv + ) + x13_ajDm + ) + x14_ajDn + ) + x15_ajDo + ) + x16_ajDp + ) + x17_ajDq + ) + x18_ajDr + ) + x19_ajDs + ) + x20_ajDt + ) + x21_ajDu + ) + ) + (f_ajD9 x12_ajDl) +{-# INLINE decompress #-} +host :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request Data.ByteString.Internal.ByteString +host + f_ajDw + ( Network.HTTP.Client.Types.Request + x1_ajDx + x2_ajDy + x3_ajDz + x4_ajDA + x5_ajDB + x6_ajDC + x7_ajDD + x8_ajDE + x9_ajDF + x10_ajDG + x11_ajDH + x12_ajDI + x13_ajDJ + x14_ajDK + x15_ajDL + x16_ajDM + x17_ajDN + x18_ajDO + x19_ajDP + x20_ajDQ + x21_ajDR + ) = + ( GHC.Base.fmap + ( \y1_ajDS -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajDx) + x2_ajDy + ) + y1_ajDS + ) + x4_ajDA + ) + x5_ajDB + ) + x6_ajDC + ) + x7_ajDD + ) + x8_ajDE + ) + x9_ajDF + ) + x10_ajDG + ) + x11_ajDH + ) + x12_ajDI + ) + x13_ajDJ + ) + x14_ajDK + ) + x15_ajDL + ) + x16_ajDM + ) + x17_ajDN + ) + x18_ajDO + ) + x19_ajDP + ) + x20_ajDQ + ) + x21_ajDR + ) + ) + (f_ajDw x3_ajDz) +{-# INLINE host #-} +hostAddress :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request (GHC.Maybe.Maybe Network.Socket.Types.HostAddress) +hostAddress + f_ajDT + ( Network.HTTP.Client.Types.Request + x1_ajDU + x2_ajDV + x3_ajDW + x4_ajDX + x5_ajDY + x6_ajDZ + x7_ajE0 + x8_ajE1 + x9_ajE2 + x10_ajE3 + x11_ajE4 + x12_ajE5 + x13_ajE6 + x14_ajE7 + x15_ajE8 + x16_ajE9 + x17_ajEa + x18_ajEb + x19_ajEc + x20_ajEd + x21_ajEe + ) = + ( GHC.Base.fmap + ( \y1_ajEf -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajDU) + x2_ajDV + ) + x3_ajDW + ) + x4_ajDX + ) + x5_ajDY + ) + x6_ajDZ + ) + x7_ajE0 + ) + x8_ajE1 + ) + x9_ajE2 + ) + y1_ajEf + ) + x11_ajE4 + ) + x12_ajE5 + ) + x13_ajE6 + ) + x14_ajE7 + ) + x15_ajE8 + ) + x16_ajE9 + ) + x17_ajEa + ) + x18_ajEb + ) + x19_ajEc + ) + x20_ajEd + ) + x21_ajEe + ) + ) + (f_ajDT x10_ajE3) +{-# INLINE hostAddress #-} +method :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request Network.HTTP.Types.Method.Method +method + f_ajEg + ( Network.HTTP.Client.Types.Request + x1_ajEh + x2_ajEi + x3_ajEj + x4_ajEk + x5_ajEl + x6_ajEm + x7_ajEn + x8_ajEo + x9_ajEp + x10_ajEq + x11_ajEr + x12_ajEs + x13_ajEt + x14_ajEu + x15_ajEv + x16_ajEw + x17_ajEx + x18_ajEy + x19_ajEz + x20_ajEA + x21_ajEB + ) = + ( GHC.Base.fmap + ( \y1_ajEC -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request y1_ajEC) + x2_ajEi + ) + x3_ajEj + ) + x4_ajEk + ) + x5_ajEl + ) + x6_ajEm + ) + x7_ajEn + ) + x8_ajEo + ) + x9_ajEp + ) + x10_ajEq + ) + x11_ajEr + ) + x12_ajEs + ) + x13_ajEt + ) + x14_ajEu + ) + x15_ajEv + ) + x16_ajEw + ) + x17_ajEx + ) + x18_ajEy + ) + x19_ajEz + ) + x20_ajEA + ) + x21_ajEB + ) + ) + (f_ajEg x1_ajEh) +{-# INLINE method #-} +onRequestBodyException :: + Control.Lens.Type.Lens' + Network.HTTP.Client.Types.Request + ( GHC.Exception.Type.SomeException -> + GHC.Types.IO () + ) +onRequestBodyException + f_ajED + ( Network.HTTP.Client.Types.Request + x1_ajEE + x2_ajEF + x3_ajEG + x4_ajEH + x5_ajEI + x6_ajEJ + x7_ajEK + x8_ajEL + x9_ajEM + x10_ajEN + x11_ajEO + x12_ajEP + x13_ajEQ + x14_ajER + x15_ajES + x16_ajET + x17_ajEU + x18_ajEV + x19_ajEW + x20_ajEX + x21_ajEY + ) = + ( GHC.Base.fmap + ( \y1_ajEZ -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajEE) + x2_ajEF + ) + x3_ajEG + ) + x4_ajEH + ) + x5_ajEI + ) + x6_ajEJ + ) + x7_ajEK + ) + x8_ajEL + ) + x9_ajEM + ) + x10_ajEN + ) + x11_ajEO + ) + x12_ajEP + ) + x13_ajEQ + ) + x14_ajER + ) + x15_ajES + ) + x16_ajET + ) + x17_ajEU + ) + y1_ajEZ + ) + x19_ajEW + ) + x20_ajEX + ) + x21_ajEY + ) + ) + (f_ajED x18_ajEV) +{-# INLINE onRequestBodyException #-} +path :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request Data.ByteString.Internal.ByteString +path + f_ajF0 + ( Network.HTTP.Client.Types.Request + x1_ajF1 + x2_ajF2 + x3_ajF3 + x4_ajF4 + x5_ajF5 + x6_ajF6 + x7_ajF7 + x8_ajF8 + x9_ajF9 + x10_ajFa + x11_ajFb + x12_ajFc + x13_ajFd + x14_ajFe + x15_ajFf + x16_ajFg + x17_ajFh + x18_ajFi + x19_ajFj + x20_ajFk + x21_ajFl + ) = + ( GHC.Base.fmap + ( \y1_ajFm -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajF1) + x2_ajF2 + ) + x3_ajF3 + ) + x4_ajF4 + ) + y1_ajFm + ) + x6_ajF6 + ) + x7_ajF7 + ) + x8_ajF8 + ) + x9_ajF9 + ) + x10_ajFa + ) + x11_ajFb + ) + x12_ajFc + ) + x13_ajFd + ) + x14_ajFe + ) + x15_ajFf + ) + x16_ajFg + ) + x17_ajFh + ) + x18_ajFi + ) + x19_ajFj + ) + x20_ajFk + ) + x21_ajFl + ) + ) + (f_ajF0 x5_ajF5) +{-# INLINE path #-} +port :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request GHC.Types.Int +port + f_ajFn + ( Network.HTTP.Client.Types.Request + x1_ajFo + x2_ajFp + x3_ajFq + x4_ajFr + x5_ajFs + x6_ajFt + x7_ajFu + x8_ajFv + x9_ajFw + x10_ajFx + x11_ajFy + x12_ajFz + x13_ajFA + x14_ajFB + x15_ajFC + x16_ajFD + x17_ajFE + x18_ajFF + x19_ajFG + x20_ajFH + x21_ajFI + ) = + ( GHC.Base.fmap + ( \y1_ajFJ -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajFo) + x2_ajFp + ) + x3_ajFq + ) + y1_ajFJ + ) + x5_ajFs + ) + x6_ajFt + ) + x7_ajFu + ) + x8_ajFv + ) + x9_ajFw + ) + x10_ajFx + ) + x11_ajFy + ) + x12_ajFz + ) + x13_ajFA + ) + x14_ajFB + ) + x15_ajFC + ) + x16_ajFD + ) + x17_ajFE + ) + x18_ajFF + ) + x19_ajFG + ) + x20_ajFH + ) + x21_ajFI + ) + ) + (f_ajFn x4_ajFr) +{-# INLINE port #-} +proxy :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request (GHC.Maybe.Maybe Network.HTTP.Client.Types.Proxy) +proxy + f_ajFK + ( Network.HTTP.Client.Types.Request + x1_ajFL + x2_ajFM + x3_ajFN + x4_ajFO + x5_ajFP + x6_ajFQ + x7_ajFR + x8_ajFS + x9_ajFT + x10_ajFU + x11_ajFV + x12_ajFW + x13_ajFX + x14_ajFY + x15_ajFZ + x16_ajG0 + x17_ajG1 + x18_ajG2 + x19_ajG3 + x20_ajG4 + x21_ajG5 + ) = + ( GHC.Base.fmap + ( \y1_ajG6 -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajFL) + x2_ajFM + ) + x3_ajFN + ) + x4_ajFO + ) + x5_ajFP + ) + x6_ajFQ + ) + x7_ajFR + ) + x8_ajFS + ) + y1_ajG6 + ) + x10_ajFU + ) + x11_ajFV + ) + x12_ajFW + ) + x13_ajFX + ) + x14_ajFY + ) + x15_ajFZ + ) + x16_ajG0 + ) + x17_ajG1 + ) + x18_ajG2 + ) + x19_ajG3 + ) + x20_ajG4 + ) + x21_ajG5 + ) + ) + (f_ajFK x9_ajFT) +{-# INLINE proxy #-} +proxySecureMode :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request Network.HTTP.Client.Types.ProxySecureMode +proxySecureMode + f_ajG7 + ( Network.HTTP.Client.Types.Request + x1_ajG8 + x2_ajG9 + x3_ajGa + x4_ajGb + x5_ajGc + x6_ajGd + x7_ajGe + x8_ajGf + x9_ajGg + x10_ajGh + x11_ajGi + x12_ajGj + x13_ajGk + x14_ajGl + x15_ajGm + x16_ajGn + x17_ajGo + x18_ajGp + x19_ajGq + x20_ajGr + x21_ajGs + ) = + ( GHC.Base.fmap + ( \y1_ajGt -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajG8) + x2_ajG9 + ) + x3_ajGa + ) + x4_ajGb + ) + x5_ajGc + ) + x6_ajGd + ) + x7_ajGe + ) + x8_ajGf + ) + x9_ajGg + ) + x10_ajGh + ) + x11_ajGi + ) + x12_ajGj + ) + x13_ajGk + ) + x14_ajGl + ) + x15_ajGm + ) + x16_ajGn + ) + x17_ajGo + ) + x18_ajGp + ) + x19_ajGq + ) + x20_ajGr + ) + y1_ajGt + ) + ) + (f_ajG7 x21_ajGs) +{-# INLINE proxySecureMode #-} +queryString :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request Data.ByteString.Internal.ByteString +queryString + f_ajGu + ( Network.HTTP.Client.Types.Request + x1_ajGv + x2_ajGw + x3_ajGx + x4_ajGy + x5_ajGz + x6_ajGA + x7_ajGB + x8_ajGC + x9_ajGD + x10_ajGE + x11_ajGF + x12_ajGG + x13_ajGH + x14_ajGI + x15_ajGJ + x16_ajGK + x17_ajGL + x18_ajGM + x19_ajGN + x20_ajGO + x21_ajGP + ) = + ( GHC.Base.fmap + ( \y1_ajGQ -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajGv) + x2_ajGw + ) + x3_ajGx + ) + x4_ajGy + ) + x5_ajGz + ) + y1_ajGQ + ) + x7_ajGB + ) + x8_ajGC + ) + x9_ajGD + ) + x10_ajGE + ) + x11_ajGF + ) + x12_ajGG + ) + x13_ajGH + ) + x14_ajGI + ) + x15_ajGJ + ) + x16_ajGK + ) + x17_ajGL + ) + x18_ajGM + ) + x19_ajGN + ) + x20_ajGO + ) + x21_ajGP + ) + ) + (f_ajGu x6_ajGA) +{-# INLINE queryString #-} +rawBody :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request GHC.Types.Bool +rawBody + f_ajGR + ( Network.HTTP.Client.Types.Request + x1_ajGS + x2_ajGT + x3_ajGU + x4_ajGV + x5_ajGW + x6_ajGX + x7_ajGY + x8_ajGZ + x9_ajH0 + x10_ajH1 + x11_ajH2 + x12_ajH3 + x13_ajH4 + x14_ajH5 + x15_ajH6 + x16_ajH7 + x17_ajH8 + x18_ajH9 + x19_ajHa + x20_ajHb + x21_ajHc + ) = + ( GHC.Base.fmap + ( \y1_ajHd -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajGS) + x2_ajGT + ) + x3_ajGU + ) + x4_ajGV + ) + x5_ajGW + ) + x6_ajGX + ) + x7_ajGY + ) + x8_ajGZ + ) + x9_ajH0 + ) + x10_ajH1 + ) + y1_ajHd + ) + x12_ajH3 + ) + x13_ajH4 + ) + x14_ajH5 + ) + x15_ajH6 + ) + x16_ajH7 + ) + x17_ajH8 + ) + x18_ajH9 + ) + x19_ajHa + ) + x20_ajHb + ) + x21_ajHc + ) + ) + (f_ajGR x11_ajH2) +{-# INLINE rawBody #-} +redirectCount :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request GHC.Types.Int +redirectCount + f_ajHe + ( Network.HTTP.Client.Types.Request + x1_ajHf + x2_ajHg + x3_ajHh + x4_ajHi + x5_ajHj + x6_ajHk + x7_ajHl + x8_ajHm + x9_ajHn + x10_ajHo + x11_ajHp + x12_ajHq + x13_ajHr + x14_ajHs + x15_ajHt + x16_ajHu + x17_ajHv + x18_ajHw + x19_ajHx + x20_ajHy + x21_ajHz + ) = + ( GHC.Base.fmap + ( \y1_ajHA -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajHf) + x2_ajHg + ) + x3_ajHh + ) + x4_ajHi + ) + x5_ajHj + ) + x6_ajHk + ) + x7_ajHl + ) + x8_ajHm + ) + x9_ajHn + ) + x10_ajHo + ) + x11_ajHp + ) + x12_ajHq + ) + y1_ajHA + ) + x14_ajHs + ) + x15_ajHt + ) + x16_ajHu + ) + x17_ajHv + ) + x18_ajHw + ) + x19_ajHx + ) + x20_ajHy + ) + x21_ajHz + ) + ) + (f_ajHe x13_ajHr) +{-# INLINE redirectCount #-} +requestBody :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request Network.HTTP.Client.Types.RequestBody +requestBody + f_ajHB + ( Network.HTTP.Client.Types.Request + x1_ajHC + x2_ajHD + x3_ajHE + x4_ajHF + x5_ajHG + x6_ajHH + x7_ajHI + x8_ajHJ + x9_ajHK + x10_ajHL + x11_ajHM + x12_ajHN + x13_ajHO + x14_ajHP + x15_ajHQ + x16_ajHR + x17_ajHS + x18_ajHT + x19_ajHU + x20_ajHV + x21_ajHW + ) = + ( GHC.Base.fmap + ( \y1_ajHX -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajHC) + x2_ajHD + ) + x3_ajHE + ) + x4_ajHF + ) + x5_ajHG + ) + x6_ajHH + ) + x7_ajHI + ) + y1_ajHX + ) + x9_ajHK + ) + x10_ajHL + ) + x11_ajHM + ) + x12_ajHN + ) + x13_ajHO + ) + x14_ajHP + ) + x15_ajHQ + ) + x16_ajHR + ) + x17_ajHS + ) + x18_ajHT + ) + x19_ajHU + ) + x20_ajHV + ) + x21_ajHW + ) + ) + (f_ajHB x8_ajHJ) +{-# INLINE requestBody #-} +requestHeaders :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request Network.HTTP.Types.Header.RequestHeaders +requestHeaders + f_ajHY + ( Network.HTTP.Client.Types.Request + x1_ajHZ + x2_ajI0 + x3_ajI1 + x4_ajI2 + x5_ajI3 + x6_ajI4 + x7_ajI5 + x8_ajI6 + x9_ajI7 + x10_ajI8 + x11_ajI9 + x12_ajIa + x13_ajIb + x14_ajIc + x15_ajId + x16_ajIe + x17_ajIf + x18_ajIg + x19_ajIh + x20_ajIi + x21_ajIj + ) = + ( GHC.Base.fmap + ( \y1_ajIk -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajHZ) + x2_ajI0 + ) + x3_ajI1 + ) + x4_ajI2 + ) + x5_ajI3 + ) + x6_ajI4 + ) + y1_ajIk + ) + x8_ajI6 + ) + x9_ajI7 + ) + x10_ajI8 + ) + x11_ajI9 + ) + x12_ajIa + ) + x13_ajIb + ) + x14_ajIc + ) + x15_ajId + ) + x16_ajIe + ) + x17_ajIf + ) + x18_ajIg + ) + x19_ajIh + ) + x20_ajIi + ) + x21_ajIj + ) + ) + (f_ajHY x7_ajI5) +{-# INLINE requestHeaders #-} +requestManagerOverride :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request (GHC.Maybe.Maybe Network.HTTP.Client.Types.Manager) +requestManagerOverride + f_ajIl + ( Network.HTTP.Client.Types.Request + x1_ajIm + x2_ajIn + x3_ajIo + x4_ajIp + x5_ajIq + x6_ajIr + x7_ajIs + x8_ajIt + x9_ajIu + x10_ajIv + x11_ajIw + x12_ajIx + x13_ajIy + x14_ajIz + x15_ajIA + x16_ajIB + x17_ajIC + x18_ajID + x19_ajIE + x20_ajIF + x21_ajIG + ) = + ( GHC.Base.fmap + ( \y1_ajIH -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajIm) + x2_ajIn + ) + x3_ajIo + ) + x4_ajIp + ) + x5_ajIq + ) + x6_ajIr + ) + x7_ajIs + ) + x8_ajIt + ) + x9_ajIu + ) + x10_ajIv + ) + x11_ajIw + ) + x12_ajIx + ) + x13_ajIy + ) + x14_ajIz + ) + x15_ajIA + ) + x16_ajIB + ) + x17_ajIC + ) + x18_ajID + ) + y1_ajIH + ) + x20_ajIF + ) + x21_ajIG + ) + ) + (f_ajIl x19_ajIE) +{-# INLINE requestManagerOverride #-} +requestVersion :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request Network.HTTP.Types.Version.HttpVersion +requestVersion + f_ajII + ( Network.HTTP.Client.Types.Request + x1_ajIJ + x2_ajIK + x3_ajIL + x4_ajIM + x5_ajIN + x6_ajIO + x7_ajIP + x8_ajIQ + x9_ajIR + x10_ajIS + x11_ajIT + x12_ajIU + x13_ajIV + x14_ajIW + x15_ajIX + x16_ajIY + x17_ajIZ + x18_ajJ0 + x19_ajJ1 + x20_ajJ2 + x21_ajJ3 + ) = + ( GHC.Base.fmap + ( \y1_ajJ4 -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajIJ) + x2_ajIK + ) + x3_ajIL + ) + x4_ajIM + ) + x5_ajIN + ) + x6_ajIO + ) + x7_ajIP + ) + x8_ajIQ + ) + x9_ajIR + ) + x10_ajIS + ) + x11_ajIT + ) + x12_ajIU + ) + x13_ajIV + ) + x14_ajIW + ) + x15_ajIX + ) + x16_ajIY + ) + y1_ajJ4 + ) + x18_ajJ0 + ) + x19_ajJ1 + ) + x20_ajJ2 + ) + x21_ajJ3 + ) + ) + (f_ajII x17_ajIZ) +{-# INLINE requestVersion #-} +responseTimeout :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request Network.HTTP.Client.Types.ResponseTimeout +responseTimeout + f_ajJ5 + ( Network.HTTP.Client.Types.Request + x1_ajJ6 + x2_ajJ7 + x3_ajJ8 + x4_ajJ9 + x5_ajJa + x6_ajJb + x7_ajJc + x8_ajJd + x9_ajJe + x10_ajJf + x11_ajJg + x12_ajJh + x13_ajJi + x14_ajJj + x15_ajJk + x16_ajJl + x17_ajJm + x18_ajJn + x19_ajJo + x20_ajJp + x21_ajJq + ) = + ( GHC.Base.fmap + ( \y1_ajJr -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajJ6) + x2_ajJ7 + ) + x3_ajJ8 + ) + x4_ajJ9 + ) + x5_ajJa + ) + x6_ajJb + ) + x7_ajJc + ) + x8_ajJd + ) + x9_ajJe + ) + x10_ajJf + ) + x11_ajJg + ) + x12_ajJh + ) + x13_ajJi + ) + x14_ajJj + ) + y1_ajJr + ) + x16_ajJl + ) + x17_ajJm + ) + x18_ajJn + ) + x19_ajJo + ) + x20_ajJp + ) + x21_ajJq + ) + ) + (f_ajJ5 x15_ajJk) +{-# INLINE responseTimeout #-} +secure :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Request GHC.Types.Bool +secure + f_ajJs + ( Network.HTTP.Client.Types.Request + x1_ajJt + x2_ajJu + x3_ajJv + x4_ajJw + x5_ajJx + x6_ajJy + x7_ajJz + x8_ajJA + x9_ajJB + x10_ajJC + x11_ajJD + x12_ajJE + x13_ajJF + x14_ajJG + x15_ajJH + x16_ajJI + x17_ajJJ + x18_ajJK + x19_ajJL + x20_ajJM + x21_ajJN + ) = + ( GHC.Base.fmap + ( \y1_ajJO -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajJt) + y1_ajJO + ) + x3_ajJv + ) + x4_ajJw + ) + x5_ajJx + ) + x6_ajJy + ) + x7_ajJz + ) + x8_ajJA + ) + x9_ajJB + ) + x10_ajJC + ) + x11_ajJD + ) + x12_ajJE + ) + x13_ajJF + ) + x14_ajJG + ) + x15_ajJH + ) + x16_ajJI + ) + x17_ajJJ + ) + x18_ajJK + ) + x19_ajJL + ) + x20_ajJM + ) + x21_ajJN + ) + ) + (f_ajJs x2_ajJu) +{-# INLINE secure #-} +shouldStripHeaderOnRedirect :: + Control.Lens.Type.Lens' + Network.HTTP.Client.Types.Request + ( Network.HTTP.Types.Header.HeaderName -> + GHC.Types.Bool + ) +shouldStripHeaderOnRedirect + f_ajJP + ( Network.HTTP.Client.Types.Request + x1_ajJQ + x2_ajJR + x3_ajJS + x4_ajJT + x5_ajJU + x6_ajJV + x7_ajJW + x8_ajJX + x9_ajJY + x10_ajJZ + x11_ajK0 + x12_ajK1 + x13_ajK2 + x14_ajK3 + x15_ajK4 + x16_ajK5 + x17_ajK6 + x18_ajK7 + x19_ajK8 + x20_ajK9 + x21_ajKa + ) = + ( GHC.Base.fmap + ( \y1_ajKb -> + ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (Network.HTTP.Client.Types.Request x1_ajJQ) + x2_ajJR + ) + x3_ajJS + ) + x4_ajJT + ) + x5_ajJU + ) + x6_ajJV + ) + x7_ajJW + ) + x8_ajJX + ) + x9_ajJY + ) + x10_ajJZ + ) + x11_ajK0 + ) + x12_ajK1 + ) + x13_ajK2 + ) + x14_ajK3 + ) + x15_ajK4 + ) + x16_ajK5 + ) + x17_ajK6 + ) + x18_ajK7 + ) + x19_ajK8 + ) + y1_ajKb + ) + x21_ajKa + ) + ) + (f_ajJP x20_ajK9) +{-# INLINE shouldStripHeaderOnRedirect #-} + +-- Network/Wreq/Internal/Lens.hs:48:1-20: Splicing declarations +seshCookies :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Session (GHC.Maybe.Maybe (GHC.IORef.IORef Network.HTTP.Client.Types.CookieJar)) +seshCookies + f_ak82 + ( Network.Wreq.Internal.Types.Session + x1_ak83 + x2_ak84 + x3_ak85 + x4_ak86 + ) = + ( GHC.Base.fmap + ( \y1_ak87 -> + ( ((Network.Wreq.Internal.Types.Session y1_ak87) x2_ak84) + x3_ak85 + ) + x4_ak86 + ) + ) + (f_ak82 x1_ak83) +{-# INLINE seshCookies #-} +seshManager :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Session Network.HTTP.Client.Types.Manager +seshManager + f_ak88 + ( Network.Wreq.Internal.Types.Session + x1_ak89 + x2_ak8a + x3_ak8b + x4_ak8c + ) = + ( GHC.Base.fmap + ( \y1_ak8d -> + ( ((Network.Wreq.Internal.Types.Session x1_ak89) y1_ak8d) + x3_ak8b + ) + x4_ak8c + ) + ) + (f_ak88 x2_ak8a) +{-# INLINE seshManager #-} +seshRun :: + Control.Lens.Type.Lens' + Network.Wreq.Internal.Types.Session + ( Network.Wreq.Internal.Types.Session -> + Network.Wreq.Internal.Types.Run Network.Wreq.Internal.Types.Body -> + Network.Wreq.Internal.Types.Run Network.Wreq.Internal.Types.Body + ) +seshRun + f_ak8e + ( Network.Wreq.Internal.Types.Session + x1_ak8f + x2_ak8g + x3_ak8h + x4_ak8i + ) = + ( GHC.Base.fmap + ( \y1_ak8j -> + ( ((Network.Wreq.Internal.Types.Session x1_ak8f) x2_ak8g) + y1_ak8j + ) + x4_ak8i + ) + ) + (f_ak8e x3_ak8h) +{-# INLINE seshRun #-} +seshRunHistory :: + Control.Lens.Type.Lens' + Network.Wreq.Internal.Types.Session + ( Network.Wreq.Internal.Types.Session -> + Network.Wreq.Internal.Types.RunHistory Network.Wreq.Internal.Types.Body -> + Network.Wreq.Internal.Types.RunHistory Network.Wreq.Internal.Types.Body + ) +seshRunHistory + f_ak8k + ( Network.Wreq.Internal.Types.Session + x1_ak8l + x2_ak8m + x3_ak8n + x4_ak8o + ) = + ( GHC.Base.fmap + ( \y1_ak8p -> + ( ((Network.Wreq.Internal.Types.Session x1_ak8l) x2_ak8m) + x3_ak8n + ) + y1_ak8p + ) + ) + (f_ak8k x4_ak8o) +{-# INLINE seshRunHistory #-} assoc :: (Eq k) => k -> IndexedTraversal' k [(k, a)] a assoc i = traverse . itraversed . index i diff --git a/Network/Wreq/Lens/TH.hs b/Network/Wreq/Lens/TH.hs index 9759e67..a3743ae 100644 --- a/Network/Wreq/Lens/TH.hs +++ b/Network/Wreq/Lens/TH.hs @@ -71,21 +71,664 @@ import Data.ByteString (ByteString) import Data.Text (Text) import Network.Wreq.Internal.Lens (assoc, assoc2) import Network.Wreq.Internal.Link -import Network.Wreq.Lens.Machinery (fieldName, makeLenses, toCamelCase) import qualified Network.HTTP.Client as HTTP import qualified Network.HTTP.Client.MultipartFormData as Form import qualified Network.HTTP.Types.Header as HTTP import qualified Network.HTTP.Types.Status as HTTP import qualified Network.Wreq.Types as Types -makeLenses ''Types.Options -makeLensesWith (lensRules & lensField .~ fieldName toCamelCase) ''HTTP.Cookie -makeLenses ''HTTP.Proxy -makeLenses ''HTTP.Response -makeLenses ''HTTP.HistoriedResponse -makeLenses ''HTTP.Status -makeLenses ''Types.Link -makeLenses ''Form.PartM +import qualified Network.HTTP.Client.MultipartFormData +import qualified Network.HTTP.Client +import qualified Network.HTTP.Client.Types +import qualified Control.Lens.Type +import qualified Network.Wreq.Internal.Types +import qualified GHC.Maybe +import qualified GHC.Base +import qualified Network.HTTP.Types.Header +import qualified Data.Text.Internal +import qualified GHC.Types +import qualified Data.ByteString.Internal +import qualified Network.HTTP.Types.Status +import qualified Network.HTTP.Types.Version +import qualified Data.ByteString.Lazy.Internal +import qualified Network.Mime + +-- these internal modules are not exposed, but we don't need them to be +import qualified Data.Time as Data.Time.Clock.Internal.UTCTime + +-- Network/Wreq/Lens/TH.hs:81:1-26: Splicing declarations +auth :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Options (GHC.Maybe.Maybe Network.Wreq.Internal.Types.Auth) +auth + f_aDCR + (Network.Wreq.Internal.Types.Options x1_aDCS x2_aDCT x3_aDCU + x4_aDCV x5_aDCW x6_aDCX x7_aDCY x8_aDCZ) + = (GHC.Base.fmap + (\ y1_aDD0 + -> (((((((Network.Wreq.Internal.Types.Options x1_aDCS) x2_aDCT) + y1_aDD0) + x4_aDCV) + x5_aDCW) + x6_aDCX) + x7_aDCY) + x8_aDCZ)) + (f_aDCR x3_aDCU) +{-# INLINE auth #-} +checkResponse :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Options (GHC.Maybe.Maybe Network.Wreq.Internal.Types.ResponseChecker) +checkResponse + f_aDD1 + (Network.Wreq.Internal.Types.Options x1_aDD2 x2_aDD3 x3_aDD4 + x4_aDD5 x5_aDD6 x6_aDD7 x7_aDD8 x8_aDD9) + = (GHC.Base.fmap + (\ y1_aDDa + -> (((((((Network.Wreq.Internal.Types.Options x1_aDD2) x2_aDD3) + x3_aDD4) + x4_aDD5) + x5_aDD6) + x6_aDD7) + x7_aDD8) + y1_aDDa)) + (f_aDD1 x8_aDD9) +{-# INLINE checkResponse #-} +cookies :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Options (GHC.Maybe.Maybe Network.HTTP.Client.Types.CookieJar) +cookies + f_aDDb + (Network.Wreq.Internal.Types.Options x1_aDDc x2_aDDd x3_aDDe + x4_aDDf x5_aDDg x6_aDDh x7_aDDi x8_aDDj) + = (GHC.Base.fmap + (\ y1_aDDk + -> (((((((Network.Wreq.Internal.Types.Options x1_aDDc) x2_aDDd) + x3_aDDe) + x4_aDDf) + x5_aDDg) + x6_aDDh) + y1_aDDk) + x8_aDDj)) + (f_aDDb x7_aDDi) +{-# INLINE cookies #-} +headers :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Options [Network.HTTP.Types.Header.Header] +headers + f_aDDl + (Network.Wreq.Internal.Types.Options x1_aDDm x2_aDDn x3_aDDo + x4_aDDp x5_aDDq x6_aDDr x7_aDDs x8_aDDt) + = (GHC.Base.fmap + (\ y1_aDDu + -> (((((((Network.Wreq.Internal.Types.Options x1_aDDm) x2_aDDn) + x3_aDDo) + y1_aDDu) + x5_aDDq) + x6_aDDr) + x7_aDDs) + x8_aDDt)) + (f_aDDl x4_aDDp) +{-# INLINE headers #-} +manager :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Options Network.Wreq.Internal.Types.Mgr +manager + f_aDDv + (Network.Wreq.Internal.Types.Options x1_aDDw x2_aDDx x3_aDDy + x4_aDDz x5_aDDA x6_aDDB x7_aDDC x8_aDDD) + = (GHC.Base.fmap + (\ y1_aDDE + -> (((((((Network.Wreq.Internal.Types.Options y1_aDDE) x2_aDDx) + x3_aDDy) + x4_aDDz) + x5_aDDA) + x6_aDDB) + x7_aDDC) + x8_aDDD)) + (f_aDDv x1_aDDw) +{-# INLINE manager #-} +params :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Options [(Data.Text.Internal.Text, + Data.Text.Internal.Text)] +params + f_aDDF + (Network.Wreq.Internal.Types.Options x1_aDDG x2_aDDH x3_aDDI + x4_aDDJ x5_aDDK x6_aDDL x7_aDDM x8_aDDN) + = (GHC.Base.fmap + (\ y1_aDDO + -> (((((((Network.Wreq.Internal.Types.Options x1_aDDG) x2_aDDH) + x3_aDDI) + x4_aDDJ) + y1_aDDO) + x6_aDDL) + x7_aDDM) + x8_aDDN)) + (f_aDDF x5_aDDK) +{-# INLINE params #-} +proxy :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Options (GHC.Maybe.Maybe Network.HTTP.Client.Types.Proxy) +proxy + f_aDDP + (Network.Wreq.Internal.Types.Options x1_aDDQ x2_aDDR x3_aDDS + x4_aDDT x5_aDDU x6_aDDV x7_aDDW x8_aDDX) + = (GHC.Base.fmap + (\ y1_aDDY + -> (((((((Network.Wreq.Internal.Types.Options x1_aDDQ) y1_aDDY) + x3_aDDS) + x4_aDDT) + x5_aDDU) + x6_aDDV) + x7_aDDW) + x8_aDDX)) + (f_aDDP x2_aDDR) +{-# INLINE proxy #-} +redirects :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Options GHC.Types.Int +redirects + f_aDDZ + (Network.Wreq.Internal.Types.Options x1_aDE0 x2_aDE1 x3_aDE2 + x4_aDE3 x5_aDE4 x6_aDE5 x7_aDE6 x8_aDE7) + = (GHC.Base.fmap + (\ y1_aDE8 + -> (((((((Network.Wreq.Internal.Types.Options x1_aDE0) x2_aDE1) + x3_aDE2) + x4_aDE3) + x5_aDE4) + y1_aDE8) + x7_aDE6) + x8_aDE7)) + (f_aDDZ x6_aDE5) +{-# INLINE redirects #-} +-- Network/Wreq/Lens/TH.hs:82:1-77: Splicing declarations +cookieCreationTime :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie Data.Time.Clock.Internal.UTCTime.UTCTime +cookieCreationTime + f_aDJm + (Network.HTTP.Client.Types.Cookie x1_aDJn x2_aDJo x3_aDJp x4_aDJq + x5_aDJr x6_aDJs x7_aDJt x8_aDJu x9_aDJv x10_aDJw x11_aDJx) + = (GHC.Base.fmap + (\ y1_aDJy + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDJn) x2_aDJo) + x3_aDJp) + x4_aDJq) + x5_aDJr) + y1_aDJy) + x7_aDJt) + x8_aDJu) + x9_aDJv) + x10_aDJw) + x11_aDJx)) + (f_aDJm x6_aDJs) +{-# INLINE cookieCreationTime #-} +cookieDomain :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie Data.ByteString.Internal.ByteString +cookieDomain + f_aDJz + (Network.HTTP.Client.Types.Cookie x1_aDJA x2_aDJB x3_aDJC x4_aDJD + x5_aDJE x6_aDJF x7_aDJG x8_aDJH x9_aDJI x10_aDJJ x11_aDJK) + = (GHC.Base.fmap + (\ y1_aDJL + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDJA) x2_aDJB) + x3_aDJC) + y1_aDJL) + x5_aDJE) + x6_aDJF) + x7_aDJG) + x8_aDJH) + x9_aDJI) + x10_aDJJ) + x11_aDJK)) + (f_aDJz x4_aDJD) +{-# INLINE cookieDomain #-} +cookieExpiryTime :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie Data.Time.Clock.Internal.UTCTime.UTCTime +cookieExpiryTime + f_aDJM + (Network.HTTP.Client.Types.Cookie x1_aDJN x2_aDJO x3_aDJP x4_aDJQ + x5_aDJR x6_aDJS x7_aDJT x8_aDJU x9_aDJV x10_aDJW x11_aDJX) + = (GHC.Base.fmap + (\ y1_aDJY + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDJN) x2_aDJO) + y1_aDJY) + x4_aDJQ) + x5_aDJR) + x6_aDJS) + x7_aDJT) + x8_aDJU) + x9_aDJV) + x10_aDJW) + x11_aDJX)) + (f_aDJM x3_aDJP) +{-# INLINE cookieExpiryTime #-} +cookieHostOnly :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie GHC.Types.Bool +cookieHostOnly + f_aDJZ + (Network.HTTP.Client.Types.Cookie x1_aDK0 x2_aDK1 x3_aDK2 x4_aDK3 + x5_aDK4 x6_aDK5 x7_aDK6 x8_aDK7 x9_aDK8 x10_aDK9 x11_aDKa) + = (GHC.Base.fmap + (\ y1_aDKb + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDK0) x2_aDK1) + x3_aDK2) + x4_aDK3) + x5_aDK4) + x6_aDK5) + x7_aDK6) + x8_aDK7) + y1_aDKb) + x10_aDK9) + x11_aDKa)) + (f_aDJZ x9_aDK8) +{-# INLINE cookieHostOnly #-} +cookieHttpOnly :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie GHC.Types.Bool +cookieHttpOnly + f_aDKc + (Network.HTTP.Client.Types.Cookie x1_aDKd x2_aDKe x3_aDKf x4_aDKg + x5_aDKh x6_aDKi x7_aDKj x8_aDKk x9_aDKl x10_aDKm x11_aDKn) + = (GHC.Base.fmap + (\ y1_aDKo + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDKd) x2_aDKe) + x3_aDKf) + x4_aDKg) + x5_aDKh) + x6_aDKi) + x7_aDKj) + x8_aDKk) + x9_aDKl) + x10_aDKm) + y1_aDKo)) + (f_aDKc x11_aDKn) +{-# INLINE cookieHttpOnly #-} +cookieLastAccessTime :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie Data.Time.Clock.Internal.UTCTime.UTCTime +cookieLastAccessTime + f_aDKp + (Network.HTTP.Client.Types.Cookie x1_aDKq x2_aDKr x3_aDKs x4_aDKt + x5_aDKu x6_aDKv x7_aDKw x8_aDKx x9_aDKy x10_aDKz x11_aDKA) + = (GHC.Base.fmap + (\ y1_aDKB + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDKq) x2_aDKr) + x3_aDKs) + x4_aDKt) + x5_aDKu) + x6_aDKv) + y1_aDKB) + x8_aDKx) + x9_aDKy) + x10_aDKz) + x11_aDKA)) + (f_aDKp x7_aDKw) +{-# INLINE cookieLastAccessTime #-} +cookieName :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie Data.ByteString.Internal.ByteString +cookieName + f_aDKC + (Network.HTTP.Client.Types.Cookie x1_aDKD x2_aDKE x3_aDKF x4_aDKG + x5_aDKH x6_aDKI x7_aDKJ x8_aDKK x9_aDKL x10_aDKM x11_aDKN) + = (GHC.Base.fmap + (\ y1_aDKO + -> ((((((((((Network.HTTP.Client.Types.Cookie y1_aDKO) x2_aDKE) + x3_aDKF) + x4_aDKG) + x5_aDKH) + x6_aDKI) + x7_aDKJ) + x8_aDKK) + x9_aDKL) + x10_aDKM) + x11_aDKN)) + (f_aDKC x1_aDKD) +{-# INLINE cookieName #-} +cookiePath :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie Data.ByteString.Internal.ByteString +cookiePath + f_aDKP + (Network.HTTP.Client.Types.Cookie x1_aDKQ x2_aDKR x3_aDKS x4_aDKT + x5_aDKU x6_aDKV x7_aDKW x8_aDKX x9_aDKY x10_aDKZ x11_aDL0) + = (GHC.Base.fmap + (\ y1_aDL1 + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDKQ) x2_aDKR) + x3_aDKS) + x4_aDKT) + y1_aDL1) + x6_aDKV) + x7_aDKW) + x8_aDKX) + x9_aDKY) + x10_aDKZ) + x11_aDL0)) + (f_aDKP x5_aDKU) +{-# INLINE cookiePath #-} +cookiePersistent :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie GHC.Types.Bool +cookiePersistent + f_aDL2 + (Network.HTTP.Client.Types.Cookie x1_aDL3 x2_aDL4 x3_aDL5 x4_aDL6 + x5_aDL7 x6_aDL8 x7_aDL9 x8_aDLa x9_aDLb x10_aDLc x11_aDLd) + = (GHC.Base.fmap + (\ y1_aDLe + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDL3) x2_aDL4) + x3_aDL5) + x4_aDL6) + x5_aDL7) + x6_aDL8) + x7_aDL9) + y1_aDLe) + x9_aDLb) + x10_aDLc) + x11_aDLd)) + (f_aDL2 x8_aDLa) +{-# INLINE cookiePersistent #-} +cookieSecureOnly :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie GHC.Types.Bool +cookieSecureOnly + f_aDLf + (Network.HTTP.Client.Types.Cookie x1_aDLg x2_aDLh x3_aDLi x4_aDLj + x5_aDLk x6_aDLl x7_aDLm x8_aDLn x9_aDLo x10_aDLp x11_aDLq) + = (GHC.Base.fmap + (\ y1_aDLr + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDLg) x2_aDLh) + x3_aDLi) + x4_aDLj) + x5_aDLk) + x6_aDLl) + x7_aDLm) + x8_aDLn) + x9_aDLo) + y1_aDLr) + x11_aDLq)) + (f_aDLf x10_aDLp) +{-# INLINE cookieSecureOnly #-} +cookieValue :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Cookie Data.ByteString.Internal.ByteString +cookieValue + f_aDLs + (Network.HTTP.Client.Types.Cookie x1_aDLt x2_aDLu x3_aDLv x4_aDLw + x5_aDLx x6_aDLy x7_aDLz x8_aDLA x9_aDLB x10_aDLC x11_aDLD) + = (GHC.Base.fmap + (\ y1_aDLE + -> ((((((((((Network.HTTP.Client.Types.Cookie x1_aDLt) y1_aDLE) + x3_aDLv) + x4_aDLw) + x5_aDLx) + x6_aDLy) + x7_aDLz) + x8_aDLA) + x9_aDLB) + x10_aDLC) + x11_aDLD)) + (f_aDLs x2_aDLu) +{-# INLINE cookieValue #-} +-- Network/Wreq/Lens/TH.hs:83:1-23: Splicing declarations +proxyHost :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Proxy Data.ByteString.Internal.ByteString +proxyHost f_aDRj (Network.HTTP.Client.Types.Proxy x1_aDRk x2_aDRl) + = (GHC.Base.fmap + (\ y1_aDRm -> (Network.HTTP.Client.Types.Proxy y1_aDRm) x2_aDRl)) + (f_aDRj x1_aDRk) +{-# INLINE proxyHost #-} +proxyPort :: + Control.Lens.Type.Lens' Network.HTTP.Client.Types.Proxy GHC.Types.Int +proxyPort f_aDRn (Network.HTTP.Client.Types.Proxy x1_aDRo x2_aDRp) + = (GHC.Base.fmap + (\ y1_aDRq -> (Network.HTTP.Client.Types.Proxy x1_aDRo) y1_aDRq)) + (f_aDRn x2_aDRp) +{-# INLINE proxyPort #-} +-- Network/Wreq/Lens/TH.hs:84:1-26: Splicing declarations +responseBody :: + forall body_a7b9 + body_aDSj. Control.Lens.Type.Lens (Network.HTTP.Client.Types.Response body_a7b9) (Network.HTTP.Client.Types.Response body_aDSj) body_a7b9 body_aDSj +responseBody + f_aDSk + (Network.HTTP.Client.Types.Response x1_aDSl x2_aDSm x3_aDSn x4_aDSo + x5_aDSp x6_aDSq x7_aDSr) + = (GHC.Base.fmap + (\ y1_aDSs + -> ((((((Network.HTTP.Client.Types.Response x1_aDSl) x2_aDSm) + x3_aDSn) + y1_aDSs) + x5_aDSp) + x6_aDSq) + x7_aDSr)) + (f_aDSk x4_aDSo) +{-# INLINE responseBody #-} +responseClose' :: + forall body_a7b9. Control.Lens.Type.Lens' (Network.HTTP.Client.Types.Response body_a7b9) Network.HTTP.Client.Types.ResponseClose +responseClose' + f_aDSt + (Network.HTTP.Client.Types.Response x1_aDSu x2_aDSv x3_aDSw x4_aDSx + x5_aDSy x6_aDSz x7_aDSA) + = (GHC.Base.fmap + (\ y1_aDSB + -> ((((((Network.HTTP.Client.Types.Response x1_aDSu) x2_aDSv) + x3_aDSw) + x4_aDSx) + x5_aDSy) + y1_aDSB) + x7_aDSA)) + (f_aDSt x6_aDSz) +{-# INLINE responseClose' #-} +responseCookieJar :: + forall body_a7b9. Control.Lens.Type.Lens' (Network.HTTP.Client.Types.Response body_a7b9) Network.HTTP.Client.Types.CookieJar +responseCookieJar + f_aDSC + (Network.HTTP.Client.Types.Response x1_aDSD x2_aDSE x3_aDSF x4_aDSG + x5_aDSH x6_aDSI x7_aDSJ) + = (GHC.Base.fmap + (\ y1_aDSK + -> ((((((Network.HTTP.Client.Types.Response x1_aDSD) x2_aDSE) + x3_aDSF) + x4_aDSG) + y1_aDSK) + x6_aDSI) + x7_aDSJ)) + (f_aDSC x5_aDSH) +{-# INLINE responseCookieJar #-} +responseHeaders :: + forall body_a7b9. Control.Lens.Type.Lens' (Network.HTTP.Client.Types.Response body_a7b9) Network.HTTP.Types.Header.ResponseHeaders +responseHeaders + f_aDSL + (Network.HTTP.Client.Types.Response x1_aDSM x2_aDSN x3_aDSO x4_aDSP + x5_aDSQ x6_aDSR x7_aDSS) + = (GHC.Base.fmap + (\ y1_aDST + -> ((((((Network.HTTP.Client.Types.Response x1_aDSM) x2_aDSN) + y1_aDST) + x4_aDSP) + x5_aDSQ) + x6_aDSR) + x7_aDSS)) + (f_aDSL x3_aDSO) +{-# INLINE responseHeaders #-} +responseOriginalRequest :: + forall body_a7b9. Control.Lens.Type.Lens' (Network.HTTP.Client.Types.Response body_a7b9) Network.HTTP.Client.Types.Request +responseOriginalRequest + f_aDSU + (Network.HTTP.Client.Types.Response x1_aDSV x2_aDSW x3_aDSX x4_aDSY + x5_aDSZ x6_aDT0 x7_aDT1) + = (GHC.Base.fmap + (\ y1_aDT2 + -> ((((((Network.HTTP.Client.Types.Response x1_aDSV) x2_aDSW) + x3_aDSX) + x4_aDSY) + x5_aDSZ) + x6_aDT0) + y1_aDT2)) + (f_aDSU x7_aDT1) +{-# INLINE responseOriginalRequest #-} +responseStatus :: + forall body_a7b9. Control.Lens.Type.Lens' (Network.HTTP.Client.Types.Response body_a7b9) Network.HTTP.Types.Status.Status +responseStatus + f_aDT3 + (Network.HTTP.Client.Types.Response x1_aDT4 x2_aDT5 x3_aDT6 x4_aDT7 + x5_aDT8 x6_aDT9 x7_aDTa) + = (GHC.Base.fmap + (\ y1_aDTb + -> ((((((Network.HTTP.Client.Types.Response y1_aDTb) x2_aDT5) + x3_aDT6) + x4_aDT7) + x5_aDT8) + x6_aDT9) + x7_aDTa)) + (f_aDT3 x1_aDT4) +{-# INLINE responseStatus #-} +responseVersion :: + forall body_a7b9. Control.Lens.Type.Lens' (Network.HTTP.Client.Types.Response body_a7b9) Network.HTTP.Types.Version.HttpVersion +responseVersion + f_aDTc + (Network.HTTP.Client.Types.Response x1_aDTd x2_aDTe x3_aDTf x4_aDTg + x5_aDTh x6_aDTi x7_aDTj) + = (GHC.Base.fmap + (\ y1_aDTk + -> ((((((Network.HTTP.Client.Types.Response x1_aDTd) y1_aDTk) + x3_aDTf) + x4_aDTg) + x5_aDTh) + x6_aDTi) + x7_aDTj)) + (f_aDTc x2_aDTe) +{-# INLINE responseVersion #-} +-- Network/Wreq/Lens/TH.hs:85:1-35: Splicing declarations +hrFinalRequest :: + forall body_a7gq. Control.Lens.Type.Lens' (Network.HTTP.Client.HistoriedResponse body_a7gq) Network.HTTP.Client.Types.Request +hrFinalRequest + f_aDXj + (Network.HTTP.Client.HistoriedResponse x1_aDXk x2_aDXl x3_aDXm) + = (GHC.Base.fmap + (\ y1_aDXn + -> ((Network.HTTP.Client.HistoriedResponse x1_aDXk) y1_aDXn) + x3_aDXm)) + (f_aDXj x2_aDXl) +{-# INLINE hrFinalRequest #-} +hrFinalResponse :: + forall body_a7gq + body_aDXi. Control.Lens.Type.Lens (Network.HTTP.Client.HistoriedResponse body_a7gq) (Network.HTTP.Client.HistoriedResponse body_aDXi) (Network.HTTP.Client.Types.Response body_a7gq) (Network.HTTP.Client.Types.Response body_aDXi) +hrFinalResponse + f_aDXo + (Network.HTTP.Client.HistoriedResponse x1_aDXp x2_aDXq x3_aDXr) + = (GHC.Base.fmap + (\ y1_aDXs + -> ((Network.HTTP.Client.HistoriedResponse x1_aDXp) x2_aDXq) + y1_aDXs)) + (f_aDXo x3_aDXr) +{-# INLINE hrFinalResponse #-} +hrRedirects :: + forall body_a7gq. Control.Lens.Type.Lens' (Network.HTTP.Client.HistoriedResponse body_a7gq) [(Network.HTTP.Client.Types.Request, + Network.HTTP.Client.Types.Response Data.ByteString.Lazy.Internal.ByteString)] +hrRedirects + f_aDXt + (Network.HTTP.Client.HistoriedResponse x1_aDXu x2_aDXv x3_aDXw) + = (GHC.Base.fmap + (\ y1_aDXx + -> ((Network.HTTP.Client.HistoriedResponse y1_aDXx) x2_aDXv) + x3_aDXw)) + (f_aDXt x1_aDXu) +{-# INLINE hrRedirects #-} +-- Network/Wreq/Lens/TH.hs:86:1-24: Splicing declarations +statusCode :: + Control.Lens.Type.Lens' Network.HTTP.Types.Status.Status GHC.Types.Int +statusCode + f_aDZa + (Network.HTTP.Types.Status.Status x1_aDZb x2_aDZc) + = (GHC.Base.fmap + (\ y1_aDZd -> (Network.HTTP.Types.Status.Status y1_aDZd) x2_aDZc)) + (f_aDZa x1_aDZb) +{-# INLINE statusCode #-} +statusMessage :: + Control.Lens.Type.Lens' Network.HTTP.Types.Status.Status Data.ByteString.Internal.ByteString +statusMessage + f_aDZe + (Network.HTTP.Types.Status.Status x1_aDZf x2_aDZg) + = (GHC.Base.fmap + (\ y1_aDZh -> (Network.HTTP.Types.Status.Status x1_aDZf) y1_aDZh)) + (f_aDZe x2_aDZg) +{-# INLINE statusMessage #-} +-- Network/Wreq/Lens/TH.hs:87:1-23: Splicing declarations +linkParams :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Link [(Data.ByteString.Internal.ByteString, + Data.ByteString.Internal.ByteString)] +linkParams + f_aE09 + (Network.Wreq.Internal.Types.Link x1_aE0a x2_aE0b) + = (GHC.Base.fmap + (\ y1_aE0c -> (Network.Wreq.Internal.Types.Link x1_aE0a) y1_aE0c)) + (f_aE09 x2_aE0b) +{-# INLINE linkParams #-} +linkURL :: + Control.Lens.Type.Lens' Network.Wreq.Internal.Types.Link Data.ByteString.Internal.ByteString +linkURL f_aE0d (Network.Wreq.Internal.Types.Link x1_aE0e x2_aE0f) + = (GHC.Base.fmap + (\ y1_aE0g -> (Network.Wreq.Internal.Types.Link y1_aE0g) x2_aE0f)) + (f_aE0d x1_aE0e) +{-# INLINE linkURL #-} +-- Network/Wreq/Lens/TH.hs:88:1-23: Splicing declarations +partContentType :: + forall m_avOQ. Control.Lens.Type.Lens' (Network.HTTP.Client.MultipartFormData.PartM m_avOQ) (GHC.Maybe.Maybe Network.Mime.MimeType) +partContentType + f_aFtV + (Network.HTTP.Client.MultipartFormData.Part x1_aFtW x2_aFtX x3_aFtY + x4_aFtZ x5_aFu0) + = (GHC.Base.fmap + (\ y1_aFu1 + -> ((((Network.HTTP.Client.MultipartFormData.Part x1_aFtW) x2_aFtX) + y1_aFu1) + x4_aFtZ) + x5_aFu0)) + (f_aFtV x3_aFtY) +{-# INLINE partContentType #-} +partFilename :: + forall m_avOQ. Control.Lens.Type.Lens' (Network.HTTP.Client.MultipartFormData.PartM m_avOQ) (GHC.Maybe.Maybe GHC.Base.String) +partFilename + f_aFu2 + (Network.HTTP.Client.MultipartFormData.Part x1_aFu3 x2_aFu4 x3_aFu5 + x4_aFu6 x5_aFu7) + = (GHC.Base.fmap + (\ y1_aFu8 + -> ((((Network.HTTP.Client.MultipartFormData.Part x1_aFu3) y1_aFu8) + x3_aFu5) + x4_aFu6) + x5_aFu7)) + (f_aFu2 x2_aFu4) +{-# INLINE partFilename #-} +partGetBody :: + forall m_avOQ + m_aFtU. Control.Lens.Type.Lens (Network.HTTP.Client.MultipartFormData.PartM m_avOQ) (Network.HTTP.Client.MultipartFormData.PartM m_aFtU) (m_avOQ Network.HTTP.Client.Types.RequestBody) (m_aFtU Network.HTTP.Client.Types.RequestBody) +partGetBody + f_aFu9 + (Network.HTTP.Client.MultipartFormData.Part x1_aFua x2_aFub x3_aFuc + x4_aFud x5_aFue) + = (GHC.Base.fmap + (\ y1_aFuf + -> ((((Network.HTTP.Client.MultipartFormData.Part x1_aFua) x2_aFub) + x3_aFuc) + x4_aFud) + y1_aFuf)) + (f_aFu9 x5_aFue) +{-# INLINE partGetBody #-} +partHeaders :: + forall m_avOQ. Control.Lens.Type.Lens' (Network.HTTP.Client.MultipartFormData.PartM m_avOQ) [Network.HTTP.Types.Header.Header] +partHeaders + f_aFug + (Network.HTTP.Client.MultipartFormData.Part x1_aFuh x2_aFui x3_aFuj + x4_aFuk x5_aFul) + = (GHC.Base.fmap + (\ y1_aFum + -> ((((Network.HTTP.Client.MultipartFormData.Part x1_aFuh) x2_aFui) + x3_aFuj) + y1_aFum) + x5_aFul)) + (f_aFug x4_aFuk) +{-# INLINE partHeaders #-} +partName :: + forall m_avOQ. Control.Lens.Type.Lens' (Network.HTTP.Client.MultipartFormData.PartM m_avOQ) Data.Text.Internal.Text +partName + f_aFun + (Network.HTTP.Client.MultipartFormData.Part x1_aFuo x2_aFup x3_aFuq + x4_aFur x5_aFus) + = (GHC.Base.fmap + (\ y1_aFut + -> ((((Network.HTTP.Client.MultipartFormData.Part y1_aFut) x2_aFup) + x3_aFuq) + x4_aFur) + x5_aFus)) + (f_aFun x1_aFuo) +{-# INLINE partName #-} responseHeader :: HTTP.HeaderName -> Traversal' (HTTP.Response body) ByteString responseHeader n = responseHeaders . assoc n diff --git a/cabal.project b/cabal.project new file mode 100644 index 0000000..358930b --- /dev/null +++ b/cabal.project @@ -0,0 +1,8 @@ +packages: . + +--TODO exposes stuff so that we can make lenses without TH +source-repository-package + type: git + location: https://github.com/georgefst/http-client + subdir: http-client + tag: bd218eff5faf19333960833e7fd28c211e2aecc4 diff --git a/wreq.cabal b/wreq.cabal index c9b9252..95fb47b 100644 --- a/wreq.cabal +++ b/wreq.cabal @@ -35,7 +35,7 @@ author: Bryan O'Sullivan maintainer: bos@serpentine.com copyright: 2014 Bryan O'Sullivan category: Web -build-type: Custom +build-type: Simple cabal-version: >=1.10 tested-with: GHC==8.2.1, GHC==8.0.2, GHC==7.10.3, GHC==7.8.4, GHC==7.6.3, GHC==7.4.2 extra-source-files: @@ -118,6 +118,7 @@ library lens >= 4.5, lens-aeson, memory, + network, mime-types, time-locale-compat, template-haskell,