Move algorithm examples to Julia code block in comment

Author: asinghvi17

GeometryOpsCore/src/types/algorithm.jl

@@ -12,6 +12,32 @@ Algorithms are:
 * May be manifold agnostic (like simplification) or restrictive (like GEOS only works on planar, PROJ algorithm for arclength and area only works on geodesic)
 * May or may not carry manifolds around, but manifold should always be accessible from manifold(alg) - it's not necessary that fixed manifold args can skip carrying the manifold around, eg in the case of Proj{Geodesic}.
 
+
+## Single manifold vs manifold independent algorithms
+
+Some algorithms only work on a single manifold (shoelace area only works on `Planar`)
+and others work on any manifold (`simplify`, `segmentize`).  They are allowed to dispatch
+on the manifold type but store that manifold as a field, and the fundamental algorithm is the 
+same.  For example the segmentize algorithm is the same (distance along line) but the implementation
+varies slightly depending on the manifold (planar, spherical, geodesic, etc).
+
+Here's a simple example of two algorithms, one only on planar and one manifold independent:
+
+```julia
+
+struct MyExternalArbitraryPackageAlgorithm <: SingleManifoldAlgorithm{Planar}
+    kw1::Int
+    kw2::String
+end # this already has the methods specified
+
+struct MyIndependentAlgorithm{M <: Manifold} <: ManifoldIndependentAlgorithm{M}
+    m::M
+    kw1::Int
+    kw2::String
+end
+
+MyIndependentAlgorithm(m::Manifold; kw1 = 1, kw2 = "hello") = MyIndependentAlgorithm(m, kw1, kw2)
+```
 =#
 
 export Algorithm, AutoAlgorithm, ManifoldIndependentAlgorithm, SingleManifoldAlgorithm, NoAlgorithm
@@ -50,18 +76,3 @@ function (Alg::Type{<: ManifoldIndependentAlgorithm{M}})(m::Manifold; kwargs...)
     # throw a WrongManifoldException and be done with it
     throw(WrongManifoldException{typeof(m), M, Alg}())
 end
-
-# for example
-
-struct MyExternalArbitraryPackageAlgorithm <: SingleManifoldAlgorithm{Planar}
-    kw1::Int
-    kw2::String
-end # this already has the methods specified
-
-struct MyIndependentAlgorithm{M <: Manifold} <: ManifoldIndependentAlgorithm{M}
-    m::M
-    kw1::Int
-    kw2::String
-end
-
-MyIndependentAlgorithm(m::Manifold; kw1 = 1, kw2 = "hello") = MyIndependentAlgorithm(m, kw1, kw2)

GeometryOpsCore/src/types/operation.jl

@@ -39,19 +39,26 @@ but if we ever implement e.g. RelateNG in GeometryOps, we can add that in.
 
 abstract type Operation{Alg <: Algorithm} end
 
-# example
-# struct XPlusOneOperation{M <: Manifold} <: Operation{NoAlgorithm{M}}
-#     m::M # the manifold always needs to be stored, since it's not a singleton
-#     x::Int
-# end
+#= 
+Here's an example of how this might work:
 
+```julia
+struct XPlusOneOperation{M <: Manifold} <: Operation{NoAlgorithm{M}}
+    m::M # the manifold always needs to be stored, since it's not a singleton
+    x::Int
+end
+```
 
-# struct Area{Alg<: Algorithm} <: Operation{Alg}
-#     alg::Alg
-# end
+```julia
+struct Area{Alg<: Algorithm} <: Operation{Alg}
+    alg::Alg
+end
 
-# Area() = Area(NoAlgorithm(Planar()))
+Area() = Area(NoAlgorithm(Planar()))
+
+function (op::Area{Alg})(data; threaded = _False(), init = 0.0) where {Alg <: Algorithm}
+    return GO.area(op.alg, data; threaded, init)
+end
+```
 
-# function (op::Area{Alg})(data; threaded = _False(), init = 0.0) where {Alg <: Algorithm}
-#     return GO.area(op.alg, data; threaded, init)
-# end
+=#