put -package:snap-core

put :: (forall r . () => (a -> BuildStep r) -> BuildStep r) -> Put a

bytestring Data.ByteString.Builder.Internal

Construct a Put action. In contrast to BuildSteps, Puts are referentially transparent in the sense that sequencing the same Put multiple times yields every time the same value with the same side-effect.

put :: MonadState s m => s -> m ()

mtl Control.Monad.State.Class Control.Monad.State.Lazy Control.Monad.State.Strict, protolude Protolude, relude Relude.Monad.Reexport, rio RIO.State, adjunctions Control.Monad.Representable.State, brick Brick.Types

Replace the state inside the monad.

put :: Monad m => s -> RWST r w s m ()

transformers Control.Monad.Trans.RWS.CPS

put s sets the state within the monad to s.

put :: (Monoid w, Monad m) => s -> RWST r w s m ()

transformers Control.Monad.Trans.RWS.Lazy Control.Monad.Trans.RWS.Strict

put s sets the state within the monad to s.

put :: Monad m => s -> StateT s m ()

transformers Control.Monad.Trans.State.Lazy Control.Monad.Trans.State.Strict

put s sets the state within the monad to s.

put :: Binary t => t -> Put

binary Data.Binary, shake Development.Shake.Classes, Cabal-syntax Distribution.Compat.Prelude

Encode a value in the Put monad.

put :: (Binary t, Generic t, GBinaryPut (Rep t)) => t -> Put

binary Data.Binary

Encode a value in the Put monad.

put :: ByteString -> Get ()

binary Data.Binary.Get.Internal

Replace the current chunk.

put :: Serialize t => Putter t

cereal Data.Serialize

Encode a value in the Put monad.

put :: (Serialize t, Generic t, GSerializePut (Rep t)) => Putter t

cereal Data.Serialize

Encode a value in the Put monad.

put :: Binary a => WriteBinHandle -> a -> IO (Bin a)

ghc GHC.Utils.Binary

put :: s -> State s ()

ghc GHC.Utils.Monad.State.Strict

put :: Putable a => String -> a -> IO (Response ByteString)

wreq Network.Wreq

Issue a PUT request.

put :: Putable a => Session -> String -> a -> IO (Response ByteString)

wreq Network.Wreq.Session

Session-specific version of put.

put :: RoutePattern -> ActionM () -> ScottyM ()

scotty Web.Scotty

put = addroute PUT

put :: MonadUnliftIO m => RoutePattern -> ActionT m () -> ScottyT m ()

scotty Web.Scotty.Trans Web.Scotty.Trans.Strict

put = addroute PUT

put :: forall s_aw4m r_aw5M . Member (State s_aw4m) r_aw5M => s_aw4m -> Sem r_aw5M ()

polysemy Polysemy.State

Update the state.

put :: MonadState m => StateType m -> m ()

monads-tf Control.Monad.State.Class Control.Monad.State.Lazy Control.Monad.State.Strict

put :: State -> Sh ()

shelly Shelly Shelly.Pipe

put :: MonadSh m => State -> m ()

shelly Shelly.Lifted

put :: ByteString -> ByteString -> WaiSession st SResponse

hspec-wai Test.Hspec.Wai

Perform a PUT request to the application under test.

put :: HasPut s a => Lens' s a

swagger2 Data.Swagger.Lens, openapi3 Data.OpenApi.Lens

put :: URL -> ContentType -> (OutputStream Builder -> IO α) -> (Response -> InputStream ByteString -> IO β) -> IO β

http-streams Network.Http.Client

Place content on the server at the given URL via an HTTP PUT request, specifying the content type and a function to write the content to the supplied OutputStream. You might see:

put "http://s3.example.com/bucket42/object149" "text/plain"
(fileBody "hello.txt") (\p i -> do
putStr $ show p
Streams.connect i stdout)

put :: Storable a => a -> Builder a

storablevector Data.StorableVector.Lazy.Builder

put :: forall s (es :: [Effect]) . (HasCallStack, State s :> es) => s -> Eff es ()

effectful-core Effectful.State.Dynamic

Set the current state to the given value.