adapted README and Doc respectively

still many things to document
maybe also better to structure by type, i.e. create a page for Identity, 
for Option, for Either, and so forth.

Author: Stephan Sahm

README.md

@@ -7,83 +7,4 @@
 
 This package defines julia implementations for the common types `Option` (aka `Maybe`), `Either` and `Try`, as well as one extra type `ContextManager` which mimics Python's `with`-ContextManager.
 
-Use it like
-```julia
-using DataTypesBasic
-```
-
-## Installation
-
-```julia
-using Pkg
-pkg"registry add https://github.com/JuliaRegistries/General"  # central julia repository
-pkg"registry add https://github.com/schlichtanders/SchlichtandersJuliaRegistry.jl"  # custom repository
-pkg"add DataTypesBasic"
-```
-
-## Option
-
-`Option{T} = Union{Identity{T}, Nothing}`
-
-Use it like
-```julia
-using DataTypesBasic
-
-fo(a::Identity{String}) = a.value * "!"
-fo(a::Nothing) = "fallback behaviour"
-
-fo(Option("hi"))  # "hi!"
-fo(Option(nothing))  # "fallback behaviour"
-fo(Option())  # "fallback behaviour"
-```
-
-The real power of `Option` comes from generic functionalities which you can define on it. `DataTypesBasic` already defines the following:
-`Base.iterate`, `Base.foreach`, `Base.map`, `Base.get`, `DataTypesBasic.iftrue`, `DataTypesBasic.iffalse`, `Base.isnothing`, `DataTypesBasic.issomething`. Please
-consult the respective function definition for details.
-
-Here an example for such a higher level perspective
-```julia
-using DataTypesBasic
-
-flatten(a::Identity) = a.value
-flatten(a::Nothing) = a
-
-function map2(f, a::Option{S}, b::Option{T}) where {S, T}  # this comes
-  nested_option = map(a) do a′
-    map(b) do b′
-      f(a′, b′)
-    end
-  end
-  flatten(nested_option)
-end
-
-map2(Option("hi"), Option("there")) do a, b
-  "$a $b"
-end  # Identity("hi there")
-
-map2(Option(1), Option()) do a, b
-  a + b
-end  # nothing
-```
-
-The package `TypeClasses.jl` (soon to come) implements a couple of such higher level concepts of immense use
-(like Functors, Applicatives and Monads).
-
-
-## [TODO] Try
-
-Please see the tests `test/Try.jl`.
-
-## [TODO] Either
-
-Please see the tests `test/Either.jl`.
-
-## [TODO] ContextManager
-
-Please see the tests `test/ContextManager.jl`.
-
-## [TODO] Other
-
-For abstraction purposes, there is also `Const` and `Identity` defined.
-
-Please see the tests `test/Const.jl` and `test/Identity.jl` respectively.
+For more details check out the [documentation](https://schlichtanders.github.io/DataTypesBasic.jl/dev/).

docs/make.jl

@@ -13,6 +13,8 @@ makedocs(;
     ),
     pages=[
         "Home" => "index.md",
+        "Manual" => "manual.md",
+        "Library" => "library.md",
     ],
 )
 

docs/src/index.md

@@ -1,12 +1,31 @@
-```@meta
-CurrentModule = DataTypesBasic
+# DataTypesBasic.jl
+
+This package defines julia implementations for the common types `Option` (aka `Maybe`), `Either` and `Try`, as well as one extra type `ContextManager` which mimics Python's `with`-ContextManager.
+
+
+## Installation
+
+```julia
+using Pkg
+pkg"registry add https://github.com/JuliaRegistries/General"  # central julia repository
+pkg"registry add https://github.com/schlichtanders/SchlichtandersJuliaRegistry.jl"  # custom repository
+pkg"add DataTypesBasic"
+```
+
+Use it like
+```julia
+using DataTypesBasic
 ```
 
-# DataTypesBasic
 
-```@index
+## Manual Outline
+
+```@contents
+Pages = ["manual.md"]
 ```
 
-```@autodocs
-Modules = [DataTypesBasic]
+## [Library Index](@id main-index)
+
+```@index
+Pages = ["library.md"]
 ```

docs/src/library.md

@@ -0,0 +1,12 @@
+```@meta
+CurrentModule = DataTypesBasic
+```
+
+# Public API
+
+```@index
+```
+
+```@autodocs
+Modules = [DataTypesBasic]
+```

docs/src/manual.md

@@ -0,0 +1,72 @@
+Manual
+======
+
+This package defines julia implementations for the common types `Option` (aka `Maybe`), `Either` and `Try`, as well as one extra type `ContextManager` which mimics Python's `with`-ContextManager.
+
+
+## Option
+
+`Option{T} = Union{Identity{T}, Nothing}`
+
+Use it like
+```julia
+using DataTypesBasic
+
+fo(a::Identity{String}) = a.value * "!"
+fo(a::Nothing) = "fallback behaviour"
+
+fo(Option("hi"))  # "hi!"
+fo(Option(nothing))  # "fallback behaviour"
+fo(Option())  # "fallback behaviour"
+```
+
+The real power of `Option` comes from generic functionalities which you can define on it. `DataTypesBasic` already defines the following:
+`Base.iterate`, `Base.foreach`, `Base.map`, `Base.get`, `DataTypesBasic.iftrue`, `DataTypesBasic.iffalse`, `Base.isnothing`, `DataTypesBasic.issomething`. Please
+consult the respective function definition for details.
+
+Here an example for such a higher level perspective
+```julia
+using DataTypesBasic
+
+flatten(a::Identity) = a.value
+flatten(a::Nothing) = a
+
+function map2(f, a::Option{S}, b::Option{T}) where {S, T}  # this comes
+  nested_option = map(a) do a′
+    map(b) do b′
+      f(a′, b′)
+    end
+  end
+  flatten(nested_option)
+end
+
+map2(Option("hi"), Option("there")) do a, b
+  "$a $b"
+end  # Identity("hi there")
+
+map2(Option(1), Option()) do a, b
+  a + b
+end  # nothing
+```
+
+The package `TypeClasses.jl` (soon to come) implements a couple of such higher level concepts of immense use
+(like Functors, Applicatives and Monads).
+
+
+## [TODO] Try
+
+Please see the tests `test/Try.jl`.
+
+## [TODO] Either
+
+Please see the tests `test/Either.jl`.
+
+## [TODO] ContextManager
+
+Please see the tests `test/ContextManager.jl`.
+
+## [TODO] Other
+
+For abstraction purposes, there is also `Const` and `Identity` defined.
+
+Please see the tests `test/Const.jl` and `test/Identity.jl` respectively.