Remove underscores from BoolsAsTypes

Author: asinghvi17

GeometryOpsCore/src/apply.jl

@@ -126,8 +126,8 @@ end
 @inline function apply(
     f::F, target, geom; calc_extent=false, threaded=false, kw...
 ) where F
-    threaded = _booltype(threaded)
-    calc_extent = _booltype(calc_extent)
+    threaded = booltype(threaded)
+    calc_extent = booltype(calc_extent)
     _apply(f, TraitTarget(target), geom; threaded, calc_extent, kw...)
 end
 
@@ -139,7 +139,7 @@ end
     # For an Array there is nothing else to do but map `_apply` over all values
     # _maptasks may run this level threaded if `threaded==true`,
     # but deeper `_apply` called in the closure will not be threaded
-    apply_to_array(i) = _apply(f, target, A[i]; threaded=_False(), kw...)
+    apply_to_array(i) = _apply(f, target, A[i]; threaded=False(), kw...)
     _maptasks(apply_to_array, eachindex(A), threaded)
 end
 # There is no trait and this is not an AbstractArray.
@@ -150,7 +150,7 @@ end
     if Tables.istable(iterable)
     _apply_table(f, target, iterable; threaded, kw...)
     else # this is probably some form of iterable...
-        if threaded isa _True
+        if threaded isa True
             # `collect` first so we can use threads
             _apply(f, target, collect(iterable); threaded, kw...)
         else
@@ -226,14 +226,14 @@ end
 # Rewrap all FeatureCollectionTrait feature collections as GI.FeatureCollection
 # Maybe use threads to call _apply on component features
 @inline function _apply(f::F, target, ::GI.FeatureCollectionTrait, fc;
-    crs=GI.crs(fc), calc_extent=_False(), threaded
+    crs=GI.crs(fc), calc_extent=False(), threaded
 ) where F
 
     # Run _apply on all `features` in the feature collection, possibly threaded
     apply_to_feature(i) =
-        _apply(f, target, GI.getfeature(fc, i); crs, calc_extent, threaded=_False())::GI.Feature
+        _apply(f, target, GI.getfeature(fc, i); crs, calc_extent, threaded=False())::GI.Feature
     features = _maptasks(apply_to_feature, 1:GI.nfeature(fc), threaded)
-    if calc_extent isa _True
+    if calc_extent isa True
         # Calculate the extent of the features
         extent = mapreduce(GI.extent, Extents.union, features)
         # Return a FeatureCollection with features, crs and calculated extent
@@ -245,13 +245,13 @@ end
 end
 # Rewrap all FeatureTrait features as GI.Feature, keeping the properties
 @inline function _apply(f::F, target, ::GI.FeatureTrait, feature;
-    crs=GI.crs(feature), calc_extent=_False(), threaded
+    crs=GI.crs(feature), calc_extent=False(), threaded
 ) where F
     # Run _apply on the contained geometry
     geometry = _apply(f, target, GI.geometry(feature); crs, calc_extent, threaded)
     # Get the feature properties
     properties = GI.properties(feature)
-    if calc_extent isa _True
+    if calc_extent isa True
         # Calculate the extent of the geometry
         extent = GI.extent(geometry)
         # Return a new Feature with the new geometry and calculated extent, but the original properties and crs
@@ -264,36 +264,36 @@ end
 # Reconstruct nested geometries,
 # maybe using threads to call _apply on component geoms
 @inline function _apply(f::F, target, trait, geom;
-    crs=GI.crs(geom), calc_extent=_False(), threaded
+    crs=GI.crs(geom), calc_extent=False(), threaded
 )::(GI.geointerface_geomtype(trait)) where F
     # Map `_apply` over all sub geometries of `geom`
     # to create a new vector of geometries
     # TODO handle zero length
-    apply_to_geom(i) = _apply(f, target, GI.getgeom(geom, i); crs, calc_extent, threaded=_False())
+    apply_to_geom(i) = _apply(f, target, GI.getgeom(geom, i); crs, calc_extent, threaded=False())
     geoms = _maptasks(apply_to_geom, 1:GI.ngeom(geom), threaded)
     return _apply_inner(geom, geoms, crs, calc_extent)
 end
 @inline function _apply(f::F, target::TraitTarget{<:PointTrait}, trait::GI.PolygonTrait, geom;
-    crs=GI.crs(geom), calc_extent=_False(), threaded
+    crs=GI.crs(geom), calc_extent=False(), threaded
 )::(GI.geointerface_geomtype(trait)) where F
     # We need to force rebuilding a LinearRing not a LineString
     geoms = _maptasks(1:GI.ngeom(geom), threaded) do i
         lr = GI.getgeom(geom, i)
         points = map(GI.getgeom(lr)) do p
-            _apply(f, target, p; crs, calc_extent, threaded=_False())
+            _apply(f, target, p; crs, calc_extent, threaded=False())
         end
         _linearring(_apply_inner(lr, points, crs, calc_extent))
     end
     return _apply_inner(geom, geoms, crs, calc_extent)
 end
-function _apply_inner(geom, geoms, crs, calc_extent::_True)
+function _apply_inner(geom, geoms, crs, calc_extent::True)
     # Calculate the extent of the sub geometries
     extent = mapreduce(GI.extent, Extents.union, geoms)
     # Return a new geometry of the same trait as `geom`,
     # holding the new `geoms` with `crs` and calculated extent
     return rebuild(geom, geoms; crs, extent)
 end
-function _apply_inner(geom, geoms, crs, calc_extent::_False)
+function _apply_inner(geom, geoms, crs, calc_extent::False)
     # Return a new geometry of the same trait as `geom`, holding the new `geoms` with `crs`
     return rebuild(geom, geoms; crs)
 end
@@ -322,7 +322,7 @@ using Base.Threads: nthreads, @threads, @spawn
 # Threading utility, modified Mason Protters threading PSA
 # run `f` over ntasks, where f receives an AbstractArray/range
 # of linear indices
-@inline function _maptasks(f::F, taskrange, threaded::_True)::Vector where F
+@inline function _maptasks(f::F, taskrange, threaded::True)::Vector where F
     ntasks = length(taskrange)
     # Customize this as needed.
     # More tasks have more overhead, but better load balancing
@@ -349,6 +349,6 @@ to lookup through the closure. This alone makes e.g. `flip` 2.5x faster!
 But it caused inference to fail, so we've removed it.  No effect on runtime so far as we can tell, 
 at least in Julia 1.11.
 =#
-@inline function _maptasks(f::F, taskrange, threaded::_False)::Vector where F
+@inline function _maptasks(f::F, taskrange, threaded::False)::Vector where F
     map(f, taskrange)
 end

GeometryOpsCore/src/applyreduce.jl

@@ -34,24 +34,24 @@ feature collections and nested geometries.
 @inline function applyreduce(
     f::F, op::O, target, geom; threaded=false, init=nothing
 ) where {F, O}
-    threaded = _booltype(threaded)
+    threaded = booltype(threaded)
     _applyreduce(f, op, TraitTarget(target), geom; threaded, init)
 end
 
 @inline _applyreduce(f::F, op::O, target, geom; threaded, init) where {F, O} =
     _applyreduce(f, op, target, GI.trait(geom), geom; threaded, init)
 # Maybe use threads reducing over arrays
 @inline function _applyreduce(f::F, op::O, target, ::Nothing, A::AbstractArray; threaded, init) where {F, O}
-    applyreduce_array(i) = _applyreduce(f, op, target, A[i]; threaded=_False(), init)
+    applyreduce_array(i) = _applyreduce(f, op, target, A[i]; threaded=False(), init)
     _mapreducetasks(applyreduce_array, op, eachindex(A), threaded; init)
 end
 # Try to applyreduce over iterables
 @inline function _applyreduce(f::F, op::O, target, ::Nothing, iterable::IterableType; threaded, init) where {F, O, IterableType}
     if Tables.istable(iterable)
         _applyreduce_table(f, op, target, iterable; threaded, init)
     else
-        applyreduce_iterable(i) = _applyreduce(f, op, target, i; threaded=_False(), init)
-        if threaded isa _True # Try to `collect` and reduce over the vector with threads
+        applyreduce_iterable(i) = _applyreduce(f, op, target, i; threaded=False(), init)
+        if threaded isa True # Try to `collect` and reduce over the vector with threads
             _applyreduce(f, op, target, collect(iterable); threaded, init)
         else
             # Try to `mapreduce` the iterable as-is
@@ -77,23 +77,23 @@ function _applyreduce_table(f::F, op::O, target::GI.FeatureTrait, iterable::Iter
 end
 # Maybe use threads reducing over features of feature collections
 @inline function _applyreduce(f::F, op::O, target, ::GI.FeatureCollectionTrait, fc; threaded, init) where {F, O}
-    applyreduce_fc(i) = _applyreduce(f, op, target, GI.getfeature(fc, i); threaded=_False(), init)
+    applyreduce_fc(i) = _applyreduce(f, op, target, GI.getfeature(fc, i); threaded=False(), init)
     _mapreducetasks(applyreduce_fc, op, 1:GI.nfeature(fc), threaded; init)
 end
 # Features just applyreduce to their geometry
 @inline _applyreduce(f::F, op::O, target, ::GI.FeatureTrait, feature; threaded, init) where {F, O} =
     _applyreduce(f, op, target, GI.geometry(feature); threaded, init)
 # Maybe use threads over components of nested geometries
 @inline function _applyreduce(f::F, op::O, target, trait, geom; threaded, init) where {F, O}
-    applyreduce_geom(i) = _applyreduce(f, op, target, GI.getgeom(geom, i); threaded=_False(), init)
+    applyreduce_geom(i) = _applyreduce(f, op, target, GI.getgeom(geom, i); threaded=False(), init)
     _mapreducetasks(applyreduce_geom, op, 1:GI.ngeom(geom), threaded; init)
 end
 # Don't thread over points it won't pay off
 @inline function _applyreduce(
     f::F, op::O, target, trait::Union{GI.LinearRing,GI.LineString,GI.MultiPoint}, geom;
     threaded, init
 ) where {F, O}
-    _applyreduce(f, op, target, GI.getgeom(geom); threaded=_False(), init)
+    _applyreduce(f, op, target, GI.getgeom(geom); threaded=False(), init)
 end
 # Apply f to the target
 @inline function _applyreduce(f::F, op::O, ::TraitTarget{Target}, ::Trait, x; kw...) where {F,O,Target,Trait<:Target} 
@@ -124,7 +124,7 @@ import Base.Threads: nthreads, @threads, @spawn
 # 
 # If you absolutely need a single chunk, then `threaded = false` will always decompose
 # to straight `mapreduce` without grouping.
-@inline function _mapreducetasks(f::F, op, taskrange, threaded::_True; init) where F
+@inline function _mapreducetasks(f::F, op, taskrange, threaded::True; init) where F
     ntasks = length(taskrange)
     # Customize this as needed.
     # More tasks have more overhead, but better load balancing
@@ -144,6 +144,6 @@ import Base.Threads: nthreads, @threads, @spawn
     # Finally we join the results into a new vector
     return mapreduce(fetch, op, tasks; init)
 end
-Base.@assume_effects :foldable function _mapreducetasks(f::F, op, taskrange, threaded::_False; init) where F
+Base.@assume_effects :foldable function _mapreducetasks(f::F, op, taskrange, threaded::False; init) where F
     mapreduce(f, op, taskrange; init)
 end

GeometryOpsCore/src/types.jl

@@ -22,7 +22,7 @@ Currently, those circumstances are `area` and `segmentize`, but this could be ex
 
 export Planar, Spherical, Geodesic
 export TraitTarget
-export BoolsAsTypes, _True, _False, _booltype
+export BoolsAsTypes, True, False, booltype
 
 """
     abstract type Manifold
@@ -130,7 +130,7 @@ the compiler to separate threaded and non-threaded code paths.
 Note that if we didn't include the parent abstract type, this would have been really 
 type unstable, since the compiler couldn't tell what would be returned!
 
-We had to add the type annotation on the `_booltype(::Bool)` method for this reason as well.
+We had to add the type annotation on the `booltype(::Bool)` method for this reason as well.
 
 TODO: should we switch to `Static.jl`?
 =#
@@ -142,25 +142,25 @@ TODO: should we switch to `Static.jl`?
 abstract type BoolsAsTypes end
 
 """
-    struct _True <: BoolsAsTypes
+    struct True <: BoolsAsTypes
 
 A struct that means `true`.
 """
-struct _True <: BoolsAsTypes end
+struct True <: BoolsAsTypes end
 
 """
-    struct _False <: BoolsAsTypes
+    struct False <: BoolsAsTypes
 
 A struct that means `false`.
 """
-struct _False <: BoolsAsTypes end
+struct False <: BoolsAsTypes end
 
 """
-    _booltype(x)
+    booltype(x)
 
 Returns a [`BoolsAsTypes`](@ref) from `x`, whether it's a boolean or a BoolsAsTypes.
 """
-function _booltype end
+function booltype end
 
-@inline _booltype(x::Bool)::BoolsAsTypes = x ? _True() : _False()
-@inline _booltype(x::BoolsAsTypes)::BoolsAsTypes = x
+@inline booltype(x::Bool)::BoolsAsTypes = x ? True() : False()
+@inline booltype(x::BoolsAsTypes)::BoolsAsTypes = x

docs/src/explanations/peculiarities.md

@@ -14,7 +14,7 @@ We use the `target` keyword to allow the user to control which kinds of geometry
 
 This also allows for a lot more type stability - when you ask for polygons, we won't return a geometrycollection with line segments.  Especially in simulation workflows, this is excellent for simplified data processing.
 
-## `_True` and `_False` (or `BoolsAsTypes`)
+## `True` and `False` (or `BoolsAsTypes`)
 
 !!! warning
     These are internals and explicitly *not* public API,

ext/GeometryOpsLibGEOSExt/GeometryOpsLibGEOSExt.jl

@@ -3,7 +3,7 @@ module GeometryOpsLibGEOSExt
 import GeometryOps as GO, LibGEOS as LG
 import GeoInterface as GI
 
-import GeometryOps: GEOS, enforce, _True, _False, _booltype
+import GeometryOps: GEOS, enforce, True, False, booltype
 
 using GeometryOps
 # The filter statement is required because in Julia, each module has its own versions of these

ext/GeometryOpsLibGEOSExt/segmentize.jl

@@ -23,7 +23,7 @@ end
 # 2 behaviours:
 # - enforce: enforce the presence of a kwargs
 # - fetch: fetch the value of a kwargs, or return a default value
-@inline function GO.segmentize(alg::GEOS, geom; threaded::Union{Bool, GO.BoolsAsTypes} = _False())
+@inline function GO.segmentize(alg::GEOS, geom; threaded::Union{Bool, GO.BoolsAsTypes} = False())
     max_distance = enforce(alg, :max_distance, GO.segmentize)
     return GO.apply(
         Base.Fix2(_wrap_and_segmentize_geos, max_distance), 

ext/GeometryOpsProjExt/reproject.jl

@@ -1,4 +1,4 @@
-import GeometryOps: GI, GeoInterface, reproject, apply, transform, _is3d, _True, _False
+import GeometryOps: GI, GeoInterface, reproject, apply, transform, _is3d, True, False
 import Proj
 
 function reproject(geom;

src/GeometryOps.jl

@@ -6,7 +6,7 @@ import GeometryOpsCore
 import GeometryOpsCore: 
                 TraitTarget,
                 Manifold, Planar, Spherical, Geodesic,
-                BoolsAsTypes, _True, _False, _booltype,
+                BoolsAsTypes, True, False, booltype,
                 apply, applyreduce, 
                 flatten, reconstruct, rebuild, unwrap, _linearring,
                 APPLY_KEYWORDS, THREADED_KEYWORD, CRS_KEYWORD, CALC_EXTENT_KEYWORD

src/methods/clipping/clipping_processor.jl

@@ -752,14 +752,14 @@ function _remove_collinear_points!(polys, remove_idx, poly_a, poly_b)
                 else
                     p3 = p
                     # check if p2 is approximately on the edge formed by p1 and p3 - remove if so
-                    if Predicates.orient(p1, p2, p3; exact = _False()) == 0
+                    if Predicates.orient(p1, p2, p3; exact = False()) == 0
                         remove_idx[i - 1] = true
                     end
                 end
                 p1, p2 = p2, p3
             end
             # Check if the first point (which is repeated as the last point) is needed 
-            if Predicates.orient(ring.geom[end - 1], ring.geom[1], ring.geom[2]; exact = _False()) == 0
+            if Predicates.orient(ring.geom[end - 1], ring.geom[1], ring.geom[2]; exact = False()) == 0
                 remove_idx[1], remove_idx[end] = true, true
             end
             # Remove unneeded collinear points

src/methods/clipping/coverage.jl

@@ -73,7 +73,7 @@ end
 _coverage(::Type{T}, ::GI.AbstractGeometryTrait, geom, xmin, xmax, ymin, ymax; kwargs...) where T = zero(T)
 
 # Polygons
-function _coverage(::Type{T}, ::GI.PolygonTrait, poly, xmin, xmax, ymin, ymax; exact = _False()) where T
+function _coverage(::Type{T}, ::GI.PolygonTrait, poly, xmin, xmax, ymin, ymax; exact = False()) where T
     GI.isempty(poly) && return zero(T)
     cov_area = _coverage(T, GI.getexterior(poly), xmin, xmax, ymin, ymax; exact)
     cov_area == 0 && return cov_area