Update docs

docs/datatypes/io.md

@@ -18,17 +18,11 @@ You can lift pure values into `IO` with `IO.succeed`:
 ```scala mdoc:silent
 import zio._
 
-val lazyValue: UIO[String] = IO.succeed("Hello World")
+val value: UIO[String] = IO.succeed("Hello World")
 ```
 
 The constructor uses non-strict evaluation, so the parameter will not be evaluated until when and if the `IO` action is executed at runtime, which is useful if the construction is costly and the value may never be needed.
 
-Alternately, you can use the `IO.succeed` constructor to perform strict evaluation of the value:
-
-```scala mdoc:silent
-val value: UIO[String] = IO.succeed("Hello World")
-```
-
 You should never use either constructor for importing impure code into `IO`. The result of doing so is undefined.
 
 ## Infallible IO
@@ -91,7 +85,7 @@ You can change an `IO[E, A]` to an `IO[E, B]` by calling the `map` method with a
 ```scala mdoc:silent
 import zio._
 
-val mappedLazyValue: UIO[Int] = IO.succeed(21).map(_ * 2)
+val mappedValue: UIO[Int] = IO.succeed(21).map(_ * 2)
 ```
 
 You can transform an `IO[E, A]` into an `IO[E2, A]` by calling the `mapError` method with a function `E => E2`:
@@ -136,8 +130,8 @@ import zio._
 ```scala mdoc:invisible
 import java.io.{ File, IOException }
 
-def openFile(s: String): IO[IOException, File] = IO.succeed(???)
-def closeFile(f: File): UIO[Unit] = IO.succeed(???)
+def openFile(s: String): IO[IOException, File] = ZIO.effect(???)
+def closeFile(f: File): UIO[Unit] = ZIO.effectTotal(???)
 def decodeData(f: File): IO[IOException, Unit] = IO.unit
 def groupData(u: Unit): IO[IOException, Unit] = IO.unit
 ```

docs/datatypes/managed.md

@@ -26,7 +26,7 @@ As shown in the previous example, a `Managed` can be created by passing an `acqu
 It can also be created from an effect. In this case the release function will do nothing.
 ```scala mdoc:silent
 import zio._
-def acquire: IO[String, Int] = IO.succeed(???)
+def acquire: IO[String, Int] = IO.effect(???)
 
 val managedFromEffect: Managed[String, Int] = Managed.fromEffect(acquire)
 ```
@@ -60,9 +60,9 @@ import zio._
 ```scala mdoc:invisible
 import java.io.{ File, IOException }
 
-def openFile(s: String): IO[IOException, File] = IO.succeed(???)
-def closeFile(f: File): UIO[Unit] = IO.succeed(???)
-def doSomething(queue: Queue[Int], file: File): UIO[Unit] = IO.succeed(???)
+def openFile(s: String): IO[IOException, File] = ZIO.effect(???)
+def closeFile(f: File): UIO[Unit] = ZIO.effectTotal(???)
+def doSomething(queue: Queue[Int], file: File): UIO[Unit] = ZIO.effectTotal(???)
 ```
 
 ```scala mdoc:silent

docs/overview/handling_errors.md

@@ -37,8 +37,8 @@ If you want to catch and recover from all types of errors and effectfully attemp
 ```scala mdoc:invisible
 import java.io.{ FileNotFoundException, IOException }
 
-def openFile(s: String): IO[IOException, Array[Byte]] =   
-  IO.succeed(???)
+def openFile(s: String): IO[IOException, Array[Byte]] = 
+  ZIO.effect(???)
 ```
 
 ```scala mdoc:silent

docs/overview/handling_resources.md

@@ -35,7 +35,7 @@ Unlike `try` / `finally`, `ensuring` works across all types of effects, includin
 
 A common use for `try` / `finally` is safely acquiring and releasing resources, such as new socket connections or opened files:
 
-```scala
+```scala 
 val handle = openFile(name)
 
 try {
@@ -51,14 +51,14 @@ The release effect is guaranteed to be executed by the runtime system, even in t
 import zio._
 import java.io.{ File, IOException }
 
-def openFile(s: String): IO[IOException, File] = IO.succeed(???)
+def openFile(s: String): IO[IOException, File] = ZIO.effect(???)
 def closeFile(f: File): UIO[Unit] = UIO.unit
 def decodeData(f: File): IO[IOException, Unit] = IO.unit
 def groupData(u: Unit): IO[IOException, Unit] = IO.unit
 ```
 
 ```scala mdoc:silent
-val groupedFileData: IO[IOException, Unit] =
+val groupedFileData: IO[IOException, Unit] = 
   openFile("data.json").bracket(closeFile(_)) { file =>
     for {
       data    <- decodeData(file)