Get rid of result types in function objects of Circular_kernel_23

Cartesian_kernel/include/CGAL/Cartesian/function_objects.h

@@ -4216,8 +4216,7 @@ namespace CartesianKernelFunctors {
          && collinear_are_ordered_along_line(t.vertex(1), p, t.vertex(2))) ||
         (o3 == COLLINEAR
          && collinear_are_ordered_along_line(t.vertex(2), p, t.vertex(3)))
-        ? result_type(ON_ORIENTED_BOUNDARY)
+        ? Oriented_side(ON_ORIENTED_BOUNDARY) : opposite(ot);
-        : opposite(ot);
     }
 
     Oriented_side

Circular_kernel_2/include/CGAL/Circular_kernel_2/function_objects_on_circle_2.h

@@ -31,25 +31,29 @@ namespace CGAL {
 namespace CircularFunctors {
 
   template < class CK >
-  class Construct_circle_2 : public CK::Linear_kernel::Construct_circle_2
+  class Construct_circle_2
+    // : public CK::Linear_kernel::Construct_circle_2
   {
-    typedef typename CK::Linear_kernel::Construct_circle_2 Base_functor;
-
     typedef typename CK::FT                         FT;
-    typedef typename CK::Linear_kernel::Point_2     Point_2;
+    typedef typename CK::Circle_2                   Circle_2;
-  public:
-    typedef typename Base_functor::result_type result_type;
-
-    using Base_functor::operator();
-
     typedef typename CK::Circular_arc_2             Circular_arc_2;
 
-    result_type
+    typedef typename CK::Linear_kernel::Construct_circle_2 Linear_Construct_circle_2;
+
+  public:
+    // using Linear_Construct_circle_2::operator();
+
+    template <class... Args>
+    decltype(auto)
+    operator()(const Args&... args) const
+    { return Linear_Construct_circle_2()(args...); }
+
+    Circle_2
     operator() ( const typename CK::Polynomial_for_circles_2_2 &eq ) {
       return construct_circle_2<CK>(eq);
     }
 
-    result_type
+    decltype(auto)
     operator() (const Circular_arc_2 & a) const {
       return (a.rep().supporting_circle());
     }

Circular_kernel_2/include/CGAL/Circular_kernel_2/function_objects_on_line_2.h

@@ -30,22 +30,28 @@ namespace CGAL {
 namespace LinearFunctors {
 
   template < class CK >
-  class Construct_line_2 : public  CK::Linear_kernel::Construct_line_2
+  class Construct_line_2
+    // : public CK::Linear_kernel::Construct_line_2
   {
     typedef typename CK::Line_arc_2            Line_arc_2;
     typedef typename CK::Line_2                Line_2;
+
+    typedef typename CK::Linear_kernel::Construct_line_2 Linear_Construct_circle_2;
+
   public:
+    // using CK::Linear_kernel::Construct_line_2::operator();
 
-    typedef typename CK::Linear_kernel::Construct_line_2::result_type
+    template <class... Args>
-      result_type;
+    decltype(auto)
-    using CK::Linear_kernel::Construct_line_2::operator();
+    operator()(const Args&... args) const
+    { return Linear_Construct_circle_2()(args...); }
 
-    result_type operator() (const Line_arc_2 & a) const
+    decltype(auto) operator() (const Line_arc_2 & a) const
     {
       return (a.rep().supporting_line());
     }
 
-    result_type
+    Line_2
     operator() ( const typename CK::Polynomial_1_2 &eq )
     {
       return construct_line_2<CK>(eq);

Circular_kernel_2/include/CGAL/Circular_kernel_2/function_objects_polynomial_circular.h

@@ -30,148 +30,115 @@
 namespace CGAL {
 namespace CircularFunctors {
 
+#define CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_(V)\
+template < class CK > \
+  class Compare_ ##V## _2 {\
+    /*: public CK::Linear_kernel::Compare_ ##V## _2{*/\
+    typedef typename CK::Comparison_result Comparison_result;\
+    typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;\
+    typedef typename CK::Linear_kernel::Compare_ ##V## _2 Linear_Compare_ ##V## _2;\
+  public:\
+    template <class... Args>\
+    Comparison_result\
+    operator()(const Args&... args) const\
+    { return Linear_Compare_ ##V## _2()(args...); }\
+    /*using CK::Linear_kernel::Compare_ ##V## _2::operator();*/\
+    Comparison_result\
+    operator() (const Circular_arc_point_2 &p0,\
+                const Circular_arc_point_2 &p1) const\
+    { return CircularFunctors::compare_ ##V <CK>(p0, p1); }\
+  };\
 
-  template < class CK >
+  CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_(x)
-  class Compare_x_2
+  CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_(y)
-    : public CK::Linear_kernel::Compare_x_2
+  CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_(xy)
-  {
-    typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
-    typedef typename CK::Point_2 Point_2;
 
-  public:
+#undef CGAL_CIRCULAR_KERNEL_MACRO_FUNCTOR_COMPARE_
-
-    typedef typename CK::Linear_kernel::Compare_x_2::result_type result_type;
-    using CK::Linear_kernel::Compare_x_2::operator();
-
-    result_type
-    operator() (const Circular_arc_point_2 &p0,
-                const Circular_arc_point_2 &p1) const
-    { return CircularFunctors::compare_x<CK>(p0, p1);}
-
-  };
-
-
-  template < class CK >
-  class Compare_y_2
-    : public CK::Linear_kernel::Compare_y_2
-  {
-    typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
-    typedef typename CK::Point_2 Point_2;
-
-  public:
-
-    typedef typename CK::Linear_kernel::Compare_y_2::result_type result_type;
-    using CK::Linear_kernel::Compare_y_2::operator();
-
-    result_type
-    operator() (const Circular_arc_point_2 &p0,
-                const Circular_arc_point_2 &p1) const
-    {return CircularFunctors::compare_y<CK>(p0, p1);}
-
-  };
-
-  template < class CK >
-  class Compare_xy_2
-    : public CK::Linear_kernel::Compare_xy_2
-  {
-    typedef typename CK::Circular_arc_point_2 Circular_arc_point_2;
-    typedef typename CK::Point_2 Point_2;
-
-  public:
-
-    typedef typename CK::Linear_kernel::Compare_xy_2::result_type result_type;
-    using CK::Linear_kernel::Compare_xy_2::operator();
-
-    result_type
-    operator() (const Circular_arc_point_2 &p0,
-                const Circular_arc_point_2 &p1) const
-    { return CircularFunctors::compare_xy<CK>(p0, p1);}
-
-  };
 
   template < class CK >
   class In_x_range_2
   {
+    typedef typename CK::Boolean                 Boolean;
     typedef typename CK::Circular_arc_2          Circular_arc_2;
     typedef typename CK::Circular_arc_point_2    Circular_arc_point_2;
     typedef typename CK::Line_arc_2              Line_arc_2;
 
   public:
-    typedef bool         result_type;
+    Boolean
-
-    result_type
     operator()(const Circular_arc_2 &a, const Circular_arc_point_2 &p) const
     { return CircularFunctors::point_in_x_range<CK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Line_arc_2 &a, const Circular_arc_point_2 &p) const
     { return CircularFunctors::point_in_x_range<CK>(a, p); }
-
   };
 
-
   template < class CK >
   class Has_on_2
-    : public CK::Linear_kernel::Has_on_2
+    // : public CK::Linear_kernel::Has_on_2
   {
+    typedef typename CK::Boolean                 Boolean;
     typedef typename CK::Circular_arc_2          Circular_arc_2;
     typedef typename CK::Circular_arc_point_2    Circular_arc_point_2;
     typedef typename CK::Line_arc_2              Line_arc_2;
     typedef typename CK::Circle_2                Circle_2;
     typedef typename CK::Line_2                  Line_2;
 
+    typedef typename CK::Linear_kernel::Has_on_2 Linear_Has_on_2;
+
   public:
-          typedef typename CK::Linear_kernel::Has_on_2::result_type result_type;
+    // using CK::Linear_kernel::Has_on_2::operator();
 
-    using CK::Linear_kernel::Has_on_2::operator();
+    template <typename A, typename B>
+    Boolean
+    operator()(const A& a, const B& b) const
+    { return Linear_Has_on_2()(a, b); }
 
-    result_type
+    Boolean
     operator()(const Circle_2 &a, const Circular_arc_point_2 &p) const
     { return CircularFunctors::has_on<CK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Line_2 &a, const Circular_arc_point_2 &p) const
     { return LinearFunctors::has_on<CK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Circular_arc_2 &a, const Circular_arc_point_2 &p) const
     { return CircularFunctors::has_on<CK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Line_arc_2 &a, const Circular_arc_point_2 &p) const
     { return CircularFunctors::has_on<CK>(a, p); }
-
   };
 
   template < class CK >
   class Compare_y_to_right_2
   {
+    typedef typename CK::Comparison_result        Comparison_result;
     typedef typename CK::Circular_arc_2           Circular_arc_2;
     typedef typename CK::Circular_arc_point_2     Circular_arc_point_2;
     typedef typename CK::Line_arc_2               Line_arc_2;
 
   public:
-    typedef CGAL::Comparison_result result_type;
+    Comparison_result
-
-    result_type
     operator()(const Circular_arc_2 &a1,
                const Circular_arc_2 &a2,
                const Circular_arc_point_2 &p) const
     { return CircularFunctors::compare_y_to_right<CK>(a1, a2, p); }
 
-    result_type
+    Comparison_result
     operator()(const Line_arc_2 &a1,
                const Line_arc_2 &a2,
                const Circular_arc_point_2 &p) const
     { return CircularFunctors::compare_y_to_right<CK>(a1, a2, p); }
 
-    result_type
+    Comparison_result
     operator()(const Line_arc_2 &a1,
                const Circular_arc_2 &a2,
                const Circular_arc_point_2 &p) const
     { return CircularFunctors::compare_y_to_right<CK>(a1, a2, p); }
 
-    result_type
+    Comparison_result
     operator()(const Circular_arc_2 &a1,
                const Line_arc_2 &a2,
                const Circular_arc_point_2 &p) const
@@ -179,21 +146,16 @@ namespace CircularFunctors {
         return CGAL::SMALLER;
       return CGAL::LARGER;
     }
-
   };
 
   template < class CK >
   class Equal_2
-  : public CK::Linear_kernel::Equal_2
+    // : public CK::Linear_kernel::Equal_2
   {
+    typedef typename CK::Boolean                 Boolean;
     typedef typename CK::Circular_arc_point_2    Circular_arc_point_2;
     typedef typename CK::Circular_arc_2          Circular_arc_2;
     typedef typename CK::Line_arc_2              Line_arc_2;
-
-  public:
-    typedef typename  CK::Linear_kernel LK;
-    typedef typename LK::Equal_2 LK_Equal_2;
-
     typedef typename CK::Point_2 Point_2;
     typedef typename CK::Vector_2 Vector_2;
     typedef typename CK::Direction_2 Direction_2;
@@ -204,69 +166,78 @@ namespace CircularFunctors {
     typedef typename CK::Iso_rectangle_2 Iso_rectangle_2;
     typedef typename CK::Circle_2 Circle_2;
 
+    typedef typename  CK::Linear_kernel::Equal_2 Linear_Equal_2;
 
-    typedef typename CK::Linear_kernel::Equal_2::result_type result_type;
+  public:
-    using CK::Linear_kernel::Equal_2::operator();
+    // using CK::Linear_kernel::Equal_2::operator();
 
-    result_type
+    template <typename A, typename B>
+    Boolean
+    operator()(const A& a, const B& b) const {
+      return Linear_Equal_2()(a, b);
+    }
+
+    Boolean
     operator() (const Circular_arc_point_2 &p0,
                 const Circular_arc_point_2 &p1) const
     { return CircularFunctors::equal<CK>(p0, p1); }
 
-    result_type
+    Boolean
     operator() (const Circular_arc_2 &a0, const Circular_arc_2 &a1) const
     { return CircularFunctors::equal<CK>(a0, a1); }
 
-    result_type
+    Boolean
     operator() (const Line_arc_2 &a0, const Line_arc_2 &a1) const
     { return CircularFunctors::equal<CK>(a0, a1); }
-
    };
 
   template < class CK >
-  class Compare_y_at_x_2 : public CK::Linear_kernel::Compare_y_at_x_2
+  class Compare_y_at_x_2
+    // : public CK::Linear_kernel::Compare_y_at_x_2
   {
+    typedef typename CK::Comparison_result       Comparison_result;
     typedef typename CK::Circular_arc_2          Circular_arc_2;
     typedef typename CK::Circular_arc_point_2    Circular_arc_point_2;
     typedef typename CK::Line_arc_2              Line_arc_2;
 
+    typedef typename CK::Linear_kernel::Compare_y_at_x_2 Linear_Compare_y_at_x_2;
+
   public:
-    typedef typename CK::Linear_kernel::Compare_y_at_x_2::result_type   result_type;
+    // using CK::Linear_kernel::Compare_y_at_x_2::operator();
 
-    using CK::Linear_kernel::Compare_y_at_x_2::operator();
+    template <class... Args>
+    Comparison_result
+    operator()(const Args&... args) const
+    { return Linear_Compare_y_at_x_2()(args...); }
 
-    result_type
+    Comparison_result
     operator() (const Circular_arc_point_2 &p,
                 const Circular_arc_2 &A1) const
     { return CircularFunctors::compare_y_at_x<CK>(p, A1); }
 
-    result_type
+    Comparison_result
     operator() (const Circular_arc_point_2 &p,
                 const Line_arc_2 &A1) const
     { return CircularFunctors::compare_y_at_x<CK>(p, A1); }
-
   };
 
   template < class CK >
   class Do_overlap_2
   {
+    typedef typename CK::Boolean        Boolean;
     typedef typename CK::Circular_arc_2 Circular_arc_2;
     typedef typename CK::Line_arc_2     Line_arc_2;
 
   public:
-    typedef bool         result_type;
+    Boolean
-
-    result_type
     operator() (const Circular_arc_2 &A1, const Circular_arc_2 &A2) const
     { return CircularFunctors::do_overlap<CK>(A1, A2); }
 
-    result_type
+    Boolean
     operator() (const Line_arc_2 &A1, const Line_arc_2 &A2) const
     { return CircularFunctors::do_overlap<CK>(A1, A2); }
-
   };
 
-
   template < class CK >
   class Make_x_monotone_2
   {
@@ -274,9 +245,6 @@ namespace CircularFunctors {
     typedef typename CK::Line_arc_2 Line_arc_2;
 
   public:
-
-     typedef void         result_type;   //!!!
-
     template < class OutputIterator >
     OutputIterator
     operator()(const Circular_arc_2 &A, OutputIterator res) const
@@ -290,7 +258,6 @@ namespace CircularFunctors {
     {
       return CircularFunctors::make_x_monotone<CK>(A,res);
     }
-
   };
 
  template < class CK >
@@ -300,9 +267,6 @@ namespace CircularFunctors {
     typedef typename CK::Line_arc_2 Line_arc_2;
 
   public:
-
-     typedef void         result_type;   //!!!
-
     template < class OutputIterator >
     OutputIterator
     operator()(const Circular_arc_2 &A, OutputIterator res) const
@@ -326,19 +290,21 @@ namespace CircularFunctors {
     { *res++ = make_object(A);
       return res;
     }
-
   };
 
   template < class CK >
   class Do_intersect_2
-    : public CK::Linear_kernel::Do_intersect_2
+    // : public CK::Linear_kernel::Do_intersect_2
   {
+    typedef typename CK::Boolean                 Boolean;
+
+    typedef typename CK::Linear_kernel::Do_intersect_2 Linear_Do_intersect_2;
+
   public:
-    typedef typename CK::Linear_kernel::Do_intersect_2::result_type   result_type;
+    template <typename A, typename B>
-    template <class T1, class T2>
+    Boolean
-    result_type
+    operator()(const A& a, const B& b) const
-    operator()(const T1& t1, const T2& t2) const
+    { return Intersections::internal::do_intersect(a, b, CK()); }
-    { return Intersections::internal::do_intersect(t1, t2, CK()); }
   };
 
   template < class CK >
@@ -347,14 +313,12 @@ namespace CircularFunctors {
   //using the Lazy_kernel as linear kernel.
     //: public CK::Linear_kernel::Intersect_2
   {
-
     typedef typename CK::Circle_2                 Circle;
     typedef typename CK::Circular_arc_2           Circular_arc;
     typedef typename CK::Line_arc_2               Line_arc;
     typedef typename CK::Line_2                   Line;
 
     public:
-
     //using CK::Linear_kernel::Intersect_2::operator();
 
     template<class A, class B>
@@ -460,7 +424,6 @@ namespace CircularFunctors {
       *res++=typename CK::Linear_kernel::Intersect_2()(l1, l2);
       return res;
     }
-
   };
 
   template < class CK >
@@ -489,42 +452,42 @@ namespace CircularFunctors {
     typedef typename CK::Line_arc_2              Line_arc_2;
 
   public:
-
+    void
-    typedef void         result_type;
-
-    result_type
     operator()(const Circular_arc_2 &A,
                const Circular_arc_point_2 &p,
                Circular_arc_2 &ca1, Circular_arc_2 &ca2) const
     { return CircularFunctors::split<CK>(A, p, ca1, ca2); }
 
-
+    void
-    result_type
     operator()(const Line_arc_2 &A,
                const Circular_arc_point_2 &p,
                Line_arc_2 &ca1, Line_arc_2 &ca2) const
     { return CircularFunctors::split<CK>(A, p, ca1, ca2); }
-
   };
 
   template < class CK >
   class Is_vertical_2
-    : public CK::Linear_kernel::Is_vertical_2
+    // : public CK::Linear_kernel::Is_vertical_2
   {
+    typedef typename CK::Boolean                 Boolean;
     typedef typename CK::Circular_arc_2          Circular_arc_2;
     typedef typename CK::Line_arc_2              Line_arc_2;
 
+    typedef typename CK::Linear_kernel::Is_vertical_2 Linear_Is_vertical_2;
+
   public:
+    // using CK::Linear_kernel::Is_vertical_2::operator();
 
-          typedef typename CK::Linear_kernel::Is_vertical_2::result_type result_type;
+    template <typename A>
+    Boolean
+    operator()(const A& a) const
+    { return Linear_Is_vertical_2()(a); }
 
-    using CK::Linear_kernel::Is_vertical_2::operator();
+    Boolean
-
-    result_type
     operator()(const Circular_arc_2 &A) const
     { return CircularFunctors::is_vertical<CK>(A); }
 
-    result_type
+    Boolean
     operator()(const Line_arc_2 &A) const
     { return CircularFunctors::is_vertical<CK>(A); }
 
@@ -533,56 +496,51 @@ namespace CircularFunctors {
   template < class CK >
   class Construct_circular_arc_2
   {
-
     typedef typename CK::FT                           FT;
-    typedef typename CK::RT                           RT;
     typedef typename CK::Point_2                      Point_2;
     typedef typename CK::Line_2                       Line_2;
     typedef typename CK::Circle_2                     Circle_2;
     typedef typename CK::Circular_arc_2               Circular_arc_2;
-    typedef typename CK::Kernel_base::Circular_arc_2  RCircular_arc_2;
     typedef typename Circular_arc_2::Rep              Rep;
     typedef typename CK::Circular_arc_point_2         Circular_arc_point_2;
 
   public:
-    typedef  Circular_arc_2 result_type;
+    Circular_arc_2
-
-    result_type
     operator()(void)
     { return Rep(); }
 
-    result_type
+    Circular_arc_2
     operator()(const Circle_2 &c) const
     { return Rep(c); }
 
-    result_type
+    Circular_arc_2
     operator()(const Circle_2 &support,
                const Circular_arc_point_2 &source,
                const Circular_arc_point_2 &target) const
     { return Rep(support,source,target); }
 
     // Not Documented
-    result_type
+    Circular_arc_2
     operator()(const Circle_2 &support,
                const Line_2 &l1, bool b1,
                const Line_2 &l2, bool b2) const
     { return Rep(support,l1,b1,l2,b2); }
 
     // Not Documented
-    result_type
+    Circular_arc_2
     operator()(const Circle_2 &c,
                const Circle_2 &c1, bool b_1,
                const Circle_2 &c2, bool b_2) const
     { return Rep(c,c1,b_1,c2,b_2); }
 
-    result_type
+    Circular_arc_2
     operator()(const Point_2 &begin,
                const Point_2 &middle,
                const Point_2 &end) const
     { return Rep(begin,middle,end); }
 
     // Not Documented
-    result_type
+    Circular_arc_2
     operator()(const Point_2 &begin,
                const Point_2 &end,
                const FT& bulge) const
@@ -600,47 +558,44 @@ namespace CircularFunctors {
     typedef typename CK::Circular_arc_point_2      Circular_arc_point_2;
     typedef typename CK::Segment_2                 Segment_2;
     typedef typename CK::Line_arc_2                Line_arc_2;
-    typedef typename CK::Kernel_base::Line_arc_2   RLine_arc_2;
     typedef typename Line_arc_2::Rep               Rep;
 
   public:
-    typedef Line_arc_2   result_type;
+    Line_arc_2
-
-    result_type
     operator()(void)
     { return Rep(); }
 
     // Not Documented
-    result_type
+    Line_arc_2
     operator()(const Line_2 &support,
                const Circle_2 &c1,const bool b1,
                const Circle_2 &c2,const bool b2) const
     { return Rep(support,c1,b1,c2,b2); }
 
     // Not Documented
-    result_type
+    Line_arc_2
     operator()(const Line_2 &support,
                const Line_2 &l1,
                const Line_2 &l2) const
     { return Rep(support,l1,l2); }
 
-    result_type
+    Line_arc_2
     operator()(const Line_2 &support,
                const Circular_arc_point_2 &p1,
                const Circular_arc_point_2 &p2) const
     { return Rep(support,p1,p2); }
 
-//     result_type
+//     Line_arc_2
 //     operator()(const Line_2 &support,
 //                const Point_2 &p1,
 //                const Point_2 &p2) const
 //     { return Rep(support,p1,p2); }
 
-    result_type
+    Line_arc_2
     operator()(const Segment_2 &s) const
     { return Rep(s); }
 
-    result_type
+    Line_arc_2
     operator()(const Point_2 &p1,
                const Point_2 &p2) const
     { return Rep(p1,p2); }
@@ -652,40 +607,32 @@ namespace CircularFunctors {
   {
     typedef typename CK::Point_2               Point_2;
     typedef typename CK::Circular_arc_point_2  Circular_arc_point_2;
-    typedef typename CK::Kernel_base::Circular_arc_point_2
-                                               RCircular_arc_point_2;
     typedef typename Circular_arc_point_2::Rep Rep;
     typedef typename Circular_arc_point_2::Root_for_circles_2_2
                                                Root_for_circles_2_2;
 
   public:
-    typedef Circular_arc_point_2 result_type;
+    Circular_arc_point_2
-
-    result_type
     operator()(void)
     { return Rep(); }
 
-    result_type
+    Circular_arc_point_2
     operator()(const Root_for_circles_2_2 & np) const
     { return Rep(np); }
 
-    result_type
+    Circular_arc_point_2
     operator()(const Point_2 & p) const
     { return Rep(p); }
 
   };
 
-
   template <class CK>
   class Compute_circular_x_2
   {
     typedef typename CK::Circular_arc_point_2   Circular_arc_point_2;
-    typedef typename CK::Root_of_2                 Root_of_2;
 
   public:
-    typedef const Root_of_2&            result_type;
+    decltype(auto) operator() (const Circular_arc_point_2 & a) const
-
-    result_type operator() (const Circular_arc_point_2 & a) const
     {
       return (a.rep().x());
     }
@@ -696,13 +643,9 @@ namespace CircularFunctors {
   class Compute_circular_y_2
   {
     typedef typename CK::Circular_arc_point_2   Circular_arc_point_2;
-    typedef typename CK::Root_of_2                 Root_of_2;
 
   public:
-
+    decltype(auto) operator() (const Circular_arc_point_2 & a) const
-    typedef const Root_of_2&            result_type;
-
-    result_type operator() (const Circular_arc_point_2 & a) const
     {
       return (a.rep().y());
     }
@@ -714,17 +657,14 @@ namespace CircularFunctors {
   {
     typedef typename CK::Circular_arc_2            Circular_arc_2;
     typedef typename CK::Line_arc_2                Line_arc_2;
-    typedef typename CK::Circular_arc_point_2      Circular_arc_point_2;
 
   public:
-    typedef const Circular_arc_point_2 &  result_type;
+    decltype(auto) operator() (const Circular_arc_2& a) const
-
-    result_type operator() (const Circular_arc_2 & a) const
     {
       return (a.rep().left());
     }
 
-    result_type operator() (const Line_arc_2 & a) const
+    decltype(auto) operator() (const Line_arc_2& a) const
     {
       return (a.rep().left());
     }
@@ -736,18 +676,14 @@ namespace CircularFunctors {
   {
     typedef typename CK::Circular_arc_2            Circular_arc_2;
     typedef typename CK::Line_arc_2                Line_arc_2;
-    typedef typename CK::Circular_arc_point_2   Circular_arc_point_2;
 
   public:
-
+    decltype(auto) operator() (const Circular_arc_2& a) const
-    typedef const Circular_arc_point_2& result_type;
-
-    result_type operator() (const Circular_arc_2 & a) const
     {
       return (a.rep().right());
     }
 
-    result_type operator() (const Line_arc_2 & a) const
+    decltype(auto) operator() (const Line_arc_2& a) const
     {
       return (a.rep().right());
     }
@@ -759,16 +695,12 @@ namespace CircularFunctors {
   {
     typedef typename CK::Circular_arc_2            Circular_arc_2;
     typedef typename CK::Line_arc_2                Line_arc_2;
-    typedef typename CK::Circular_arc_point_2   Circular_arc_point_2;
 
   public:
-
+    decltype(auto) operator() (const Circular_arc_2& a) const
-    typedef const Circular_arc_point_2& result_type;
-
-    result_type operator() (const Circular_arc_2 & a) const
     { return a.rep().source(); }
 
-    result_type operator() (const Line_arc_2 & a) const
+    decltype(auto) operator() (const Line_arc_2& a) const
     { return a.rep().source();}
 
   };
@@ -779,16 +711,12 @@ namespace CircularFunctors {
   {
     typedef typename CK::Circular_arc_2            Circular_arc_2;
     typedef typename CK::Line_arc_2                Line_arc_2;
-    typedef typename CK::Circular_arc_point_2   Circular_arc_point_2;
 
   public:
-
+    decltype(auto) operator() (const Circular_arc_2& a) const
-    typedef const Circular_arc_point_2& result_type;
-
-    result_type operator() (const Circular_arc_2 & a) const
     { return a.rep().target();}
 
-    result_type operator() (const Line_arc_2 & a) const
+    decltype(auto) operator() (const Line_arc_2& a) const
     { return a.rep().target();}
 
   };
@@ -796,19 +724,17 @@ namespace CircularFunctors {
   template <class CK>
   class Is_x_monotone_2
   {
+    typedef typename CK::Boolean                   Boolean;
     typedef typename CK::Circular_arc_2            Circular_arc_2;
     typedef typename CK::Line_arc_2                Line_arc_2;
 
   public:
-
+    Boolean operator() (const Circular_arc_2 & a) const
-    typedef bool         result_type;
-
-    result_type operator() (const Circular_arc_2 & a) const
     {
       return (a.rep().is_x_monotone());
     }
 
-    result_type operator() (const Line_arc_2 & a) const
+    Boolean operator() (const Line_arc_2 & a) const
     {
       return (a.rep().is_x_monotone());
     }
@@ -818,19 +744,17 @@ namespace CircularFunctors {
   template <class CK>
   class Is_y_monotone_2
   {
+    typedef typename CK::Boolean                   Boolean;
     typedef typename CK::Circular_arc_2            Circular_arc_2;
     typedef typename CK::Line_arc_2                Line_arc_2;
 
   public:
-
+    Boolean operator() (const Circular_arc_2& a) const
-    typedef bool         result_type;
-
-    result_type operator() (const Circular_arc_2 & a) const
     {
       return (a.rep().is_y_monotone());
     }
 
-    result_type operator() (const Line_arc_2 & a) const
+    Boolean operator() (const Line_arc_2& a) const
     {
       return (a.rep().is_y_monotone());
     }
@@ -839,48 +763,58 @@ namespace CircularFunctors {
 
   template <class CK>
   class Construct_bbox_2
-    : public CK::Linear_kernel::Construct_bbox_2
+    // : public CK::Linear_kernel::Construct_bbox_2
   {
     typedef typename CK::Circular_arc_2            Circular_arc_2;
     typedef typename CK::Circular_arc_point_2      Circular_arc_point_2;
     typedef typename CK::Line_arc_2                Line_arc_2;
     typedef typename CK::Circle_2                  Circle_2;
 
+    typedef typename CK::Linear_kernel::Construct_bbox_2 Linear_Construct_bbox_2;
+
   public:
+    // using CK::Linear_kernel::Construct_bbox_2::operator();
 
-    typedef typename CK::Linear_kernel::Construct_bbox_2::result_type result_type;
+    template <typename A>
-    using CK::Linear_kernel::Construct_bbox_2::operator();
+    decltype(auto)
+    operator()(const A& a) const
+    { return Linear_Construct_bbox_2()(a); }
 
-    result_type operator() (const Circular_arc_point_2 & a) const
+    decltype(auto) operator() (const Circular_arc_point_2& a) const
     {
       return a.rep().bbox();
     }
 
-    result_type operator() (const Circular_arc_2 & a) const
+    decltype(auto) operator() (const Circular_arc_2& a) const
     {
       return a.rep().bbox();
     }
 
-    result_type operator() (const Line_arc_2 & a) const
+    decltype(auto) operator() (const Line_arc_2& a) const
     {
       return a.rep().bbox();
     }
-
   };
 
   template <class CK>
   class Bounded_side_2
-    : public CK::Linear_kernel::Bounded_side_2
+    // : public CK::Linear_kernel::Bounded_side_2
   {
+    typedef typename CK::Bounded_side          Bounded_side;
     typedef typename CK::Circle_2              Circle_2;
     typedef typename CK::Circular_arc_point_2  Circular_arc_point_2;
 
+    typedef typename CK::Linear_kernel::Bounded_side_2 Linear_Bounded_side_2;
+
   public:
-    typedef typename CK::Linear_kernel::Bounded_side_2::result_type result_type;
+    // using CK::Linear_kernel::Bounded_side_2::operator();
 
-    using CK::Linear_kernel::Bounded_side_2::operator();
+    template <typename A, typename B>
+    Bounded_side
+    operator()(const A& a, const B& b) const
+    { return Linear_Bounded_side_2()(a, b); }
 
-    result_type
+    Bounded_side
     operator()(const Circle_2& c, const Circular_arc_point_2& p) const
     { return CircularFunctors::bounded_side<CK>(c,p); }
 
@@ -888,17 +822,23 @@ namespace CircularFunctors {
 
   template <class CK>
   class Has_on_bounded_side_2
-    : public CK::Linear_kernel::Has_on_bounded_side_2
+    // : public CK::Linear_kernel::Has_on_bounded_side_2
   {
+    typedef typename CK::Boolean               Boolean;
     typedef typename CK::Circle_2              Circle_2;
     typedef typename CK::Circular_arc_point_2  Circular_arc_point_2;
 
+    typedef typename CK::Linear_kernel::Has_on_bounded_side_2 Linear_Has_on_bounded_side_2;
+
   public:
-    typedef typename CK::Linear_kernel::Has_on_bounded_side_2::result_type result_type;
+    // using CK::Linear_kernel::Has_on_bounded_side_2::operator();
 
-    using CK::Linear_kernel::Has_on_bounded_side_2::operator();
+    template <typename A, typename B>
+    Boolean
+    operator()(const A& a, const B& b) const
+    { return Linear_Has_on_bounded_side_2()(a, b); }
 
-    result_type
+    Boolean
     operator()(const Circle_2& c, const Circular_arc_point_2& p) const
     { return CK().bounded_side_2_object()(c,p) == ON_BOUNDED_SIDE; }
 
@@ -906,20 +846,25 @@ namespace CircularFunctors {
 
   template <class CK>
   class Has_on_unbounded_side_2
-    : public CK::Linear_kernel::Has_on_unbounded_side_2
+    // : public CK::Linear_kernel::Has_on_unbounded_side_2
   {
+    typedef typename CK::Boolean               Boolean;
     typedef typename CK::Circle_2              Circle_2;
     typedef typename CK::Circular_arc_point_2  Circular_arc_point_2;
 
+    typedef typename CK::Linear_kernel::Has_on_unbounded_side_2 Linear_Has_on_unbounded_side_2;
+
   public:
-    typedef typename CK::Linear_kernel::Has_on_unbounded_side_2::result_type result_type;
+    // using CK::Linear_kernel::Has_on_unbounded_side_2::operator();
 
-    using CK::Linear_kernel::Has_on_unbounded_side_2::operator();
+    template <typename A, typename B>
+    Boolean
+    operator()(const A& a, const B& b) const
+    { return Linear_Has_on_unbounded_side_2()(a, b); }
 
-    result_type
+    Boolean
     operator()(const Circle_2& c, const Circular_arc_point_2& p) const
     { return CK().bounded_side_2_object()(c,p) == ON_UNBOUNDED_SIDE; }
-
   };
 
 #ifndef CGAL_NO_DEPRECATED_CODE
@@ -927,31 +872,21 @@ namespace CircularFunctors {
   class Construct_supporting_circle_2
   {
     typedef typename CK::Circular_arc_2            Circular_arc_2;
-    typedef typename CK::Circle_2                  Circle_2;
 
   public:
-
+    CGAL_DEPRECATED decltype(auto) operator() (const Circular_arc_2 & a) const
-    typedef Circle_2             result_type;
-
-    CGAL_DEPRECATED result_type operator() (const Circular_arc_2 & a) const
     {
       return a.rep().supporting_circle();
     }
   };
 
-
   template <class CK>
   class Construct_supporting_line_2
   {
     typedef typename CK::Line_arc_2            Line_arc_2;
-    typedef typename CK::Line_2                Line_2;
-    typedef typename CK::Circle_2              Circle_2;
 
   public:
-
+    CGAL_DEPRECATED decltype(auto) operator() (const Line_arc_2 & a) const
-    typedef Line_2               result_type;
-
-    CGAL_DEPRECATED result_type operator() (const Line_arc_2 & a) const
     {
       return a.rep().supporting_line();
     }
@@ -960,24 +895,28 @@ namespace CircularFunctors {
 
   template <typename CK>
   class Construct_center_2
-            : public CK::Linear_kernel::Construct_center_2
+    // : public CK::Linear_kernel::Construct_center_2
   {
     typedef typename CK::Circular_arc_2  Circular_arc_2;
-  public:
-    typedef typename CK::Linear_kernel::Construct_center_2::result_type result_type;
-   using CK::Linear_kernel::Construct_center_2::operator();
 
-    result_type
+    typedef typename CK::Linear_kernel::Construct_center_2 Linear_Construct_center_2;
+
+  public:
+    // using CK::Linear_kernel::Construct_center_2::operator();
+
+    template <typename A>
+    decltype(auto)
+    operator()(const A& a) const
+    { return Linear_Construct_center_2()(a); }
+
+    decltype(auto)
     operator()(const Circular_arc_2& c) const
     { return c.rep().center(); }
-
   };
 
   template <typename CK>
   class Compute_squared_radius_2
   {
-
-  private:
     typedef typename CK::Circular_arc_2  Circular_arc_2;
     typedef typename CK::Linear_kernel LK;
     typedef typename LK::Compute_squared_radius_2 LK_Compute_squared_radius_2;

Circular_kernel_2/include/CGAL/Circular_kernel_intersections.h

@@ -54,7 +54,7 @@ namespace Intersections { \
   } \
 template <class K> \
 inline \
-bool \
+typename K::Boolean \
 do_intersect(const A <K> &c1, const B <K> &c2) \
 { \
   return typename K::Do_intersect_2()(c1, c2); \

Circular_kernel_2/include/CGAL/Filtered_bbox_circular_kernel_2/bbox_filtered_predicates.h

@@ -33,6 +33,7 @@ namespace Bbox_functors {
 template <class BK>
 class Compare_x_2 : public BK::Circular_kernel:: template Base< BK >::Type::Compare_x_2
 {
+  typedef typename BK::Comparison_result                       Comparison_result;
   typedef typename BK::Circular_arc_point_2                    Circular_arc_point_2;
   typedef typename BK::Point_2                                 Point_2;
   typedef typename BK::Circular_kernel::
@@ -40,12 +41,9 @@ class Compare_x_2 : public BK::Circular_kernel:: template Base< BK >::Type::Comp
   typedef CK_Compare_x_2 Base;
 
 public:
-
-  typedef typename CK_Compare_x_2::result_type result_type;
-
   using Base::operator();
 
-  result_type
+  Comparison_result
   operator()( const Circular_arc_point_2 &a, const Circular_arc_point_2 &b) const
   {
     Bbox_2 bb1=a.bbox(),bb2=b.bbox();
@@ -65,16 +63,15 @@ public:
 template <class BK>
 class Compare_y_2 : public BK::Circular_kernel:: template Base< BK >::Type::Compare_y_2
 {
+  typedef typename BK::Comparison_result                       Comparison_result;
   typedef typename BK::Circular_arc_point_2                    Circular_arc_point_2;
   typedef typename BK::Point_2                                 Point_2;
   typedef typename BK::Circular_kernel::
     template Base< BK >::Type::Compare_y_2                     CK_Compare_y_2;
   typedef CK_Compare_y_2 Base;
+
 public:
-
+  Comparison_result
-  typedef typename CK_Compare_y_2::result_type result_type;
-
-  result_type
   operator() (const Point_2 &p0,
               const Point_2 &p1) const
   {
@@ -83,7 +80,7 @@ public:
 
   using Base::operator();
 
-  result_type
+  Comparison_result
   operator()( const Circular_arc_point_2 &a, const Circular_arc_point_2 &b) const
   {
     Bbox_2 bb1=a.bbox(),bb2=b.bbox();
@@ -105,17 +102,15 @@ class Compare_xy_2 : public BK::Circular_kernel:: template Base< BK >::Type::Com
   typedef typename BK::Circular_kernel::
   template Base< BK >::Type::Compare_xy_2                      CK_Compare_xy_2;
   typedef CK_Compare_xy_2 Base;
+
+  typedef typename BK::Comparison_result                       Comparison_result;
   typedef typename BK::Circular_arc_point_2                    Circular_arc_point_2;
   typedef typename BK::Point_2                                 Point_2;
 
 public:
-
-  typedef typename Base::result_type result_type;
-
   using Base::operator();
-public:
 
-  result_type
+  Comparison_result
   operator()( const Circular_arc_point_2 &a, const Circular_arc_point_2 &b) const
   {
     typename BK::Compare_x_2 compx;
@@ -137,20 +132,18 @@ class In_x_range_2 : public BK::Circular_kernel:: template Base< BK >::Type::In_
   typedef typename BK::Circular_kernel::
     template Base< BK >::Type::In_x_range_2                    CK_In_x_range_2;
   typedef CK_In_x_range_2 Base;
+
+  typedef typename BK::Boolean                                 Boolean;
   typedef typename BK::Circular_arc_point_2                    Circular_arc_point_2;
   typedef typename BK::Circular_arc_2                          Circular_arc_2;
   typedef typename BK::Line_arc_2                              Line_arc_2;
 
 public:
-
-  typedef typename CK_In_x_range_2::result_type result_type;
-
   using Base::operator();
 
 private:
-
   template <class Arc_2>
-  result_type
+  Boolean
   _in_x_range_2(const Arc_2 &a, const Circular_arc_point_2 &p) const
   {
 
@@ -179,42 +172,36 @@ private:
   }
 
 public:
-
+  Boolean
-  result_type
   operator()( const Circular_arc_2 &a, const Circular_arc_point_2 &p) const
   {
     CGAL_precondition( a.is_x_monotone());
     return _in_x_range_2(a,p);
   }
 
-  result_type
+  Boolean
   operator()( const Line_arc_2 &a, const Circular_arc_point_2 &p) const
   { return _in_x_range_2(a,p);}
-
-
 };
 
-
 template <class BK>
 class Compare_y_at_x_2 : public BK::Circular_kernel:: template Base< BK >::Type::Compare_y_at_x_2
 {
   typedef typename BK::Circular_kernel::
     template Base< BK >::Type::Compare_y_at_x_2                         CK_Compare_y_at_x_2;
   typedef CK_Compare_y_at_x_2 Base;
+
+  typedef typename BK::Comparison_result                                Comparison_result;
   typedef typename BK::Circular_arc_2                                   Circular_arc_2;
   typedef typename BK::Circular_arc_point_2                             Circular_arc_point_2;
   typedef typename BK::Line_arc_2                                       Line_arc_2;
 
 public:
-
-  typedef typename CK_Compare_y_at_x_2::result_type result_type;
-
   using Base::operator();
 
 private:
-
   template <class Arc_2>
-  result_type
+  Comparison_result
   _compare_y_at_x_2(const Circular_arc_point_2 &p,const Arc_2 &a) const
   {
     CGAL_precondition_code(bool tmp=In_x_range_2<BK>()(a,p));
@@ -232,41 +219,36 @@ private:
   }
 
 public:
-
+  Comparison_result
-  result_type
   operator()( const Circular_arc_point_2 &p,const Circular_arc_2 &a ) const
   {
     CGAL_precondition( a.is_x_monotone());
     return _compare_y_at_x_2(p,a);
   }
 
-  result_type
+  Comparison_result
   operator()( const Circular_arc_point_2 &p,const Line_arc_2 &a ) const
   {return _compare_y_at_x_2(p,a);}
-
 };
 
-
 template <class BK>
 class Has_on_2 : public BK::Circular_kernel:: template Base< BK >::Type::Has_on_2
 {
   typedef typename BK::Circular_kernel::
     template Base< BK >::Type::Has_on_2                                 CK_Has_on_2;
   typedef CK_Has_on_2 Base;
+
+  typedef typename BK::Boolean                                          Boolean;
   typedef typename BK::Circular_arc_2                                   Circular_arc_2;
   typedef typename BK::Circular_arc_point_2                             Circular_arc_point_2;
   typedef typename BK::Line_arc_2                                       Line_arc_2;
 
 public:
-
-  typedef typename CK_Has_on_2::result_type result_type;
-
   using Base::operator();
 
 private:
-
   template <class Arc_2>
-  result_type
+  Boolean
   _has_on_2(const Arc_2 &a, const Circular_arc_point_2 &p) const
   {
     Bbox_2 bb1=a.bbox(),bb2=p.bbox();
@@ -278,27 +260,26 @@ private:
   }
 
 public:
-
+  Boolean
-  result_type
   operator()( const Circular_arc_2 &a,const Circular_arc_point_2 &p ) const
   {
     CGAL_precondition( a.is_x_monotone());
     return _has_on_2(a,p);
   }
 
-  result_type
+  Boolean
   operator()( const Line_arc_2 &a, const Circular_arc_point_2 &p ) const
   {return _has_on_2(a,p);}
-
 };
 
-
 template <class BK>
 class Equal_2
   : public BK::Circular_kernel:: template Base< BK >::Type::Equal_2
 {
   typedef typename BK::Circular_kernel::
     template Base< BK >::Type::Equal_2                                  CK_Equal_2;
+
+  typedef typename BK::Boolean                                          Boolean;
   typedef typename BK::Circular_arc_2                                   Circular_arc_2;
   typedef typename BK::Point_2                                          Point_2;
   typedef typename BK::Direction_2                                      Direction_2;
@@ -315,15 +296,11 @@ class Equal_2
   typedef CK_Equal_2 Base;
 
 public:
-
-  typedef typename CK_Equal_2::result_type result_type;
-
   using Base::operator();
 
 private:
-
   template <class Arc_2>
-  result_type
+  Boolean
   _equal_2(const Arc_2 &a,const Arc_2 &b) const
   {
     Bbox_2 bb11=a.source().bbox(),
@@ -346,8 +323,7 @@ private:
   }
 
 public:
-
+  Boolean
-  result_type
   operator()( const Circular_arc_point_2 &a ,
               const Circular_arc_point_2 &b) const
   {
@@ -361,14 +337,15 @@ public:
 
   /* WAS THAT HERE FOR OTHER COMPILERS THAN VC* ???
   // redefine to solve ambiguous call error
-  result_type
+  Boolean
   operator()( const Point_2 &a ,
   const Point_2 &b) const
   {
   return CK_Equal_2()( a, b);
   }
   */
-  result_type
+
+  Boolean
   operator()( const Circular_arc_2 &a , const Circular_arc_2 &b ) const
   {
     CGAL_precondition( a.is_x_monotone());
@@ -377,17 +354,17 @@ public:
     return _equal_2(a,b);
   }
 
-  result_type
+  Boolean
   operator()( const Line_arc_2 &a ,
               const Line_arc_2 &b ) const
   {  return _equal_2(a,b);}
 
-  result_type
+  Boolean
   operator()( const Circular_arc_2 & ,
               const Line_arc_2 & ) const
   {  return false;}
 
-  result_type
+  Boolean
   operator()( const Line_arc_2 & ,
               const Circular_arc_2 & ) const
   {  return false;}
@@ -401,19 +378,17 @@ class Do_overlap_2 : public BK::Circular_kernel:: template Base< BK >::Type::Do_
   typedef typename BK::Circular_kernel::
     template Base< BK >::Type::Do_overlap_2                           CK_Do_overlap_2;
   typedef CK_Do_overlap_2 Base;
+
+  typedef typename BK::Boolean                                        Boolean;
   typedef typename BK::Circular_arc_2                                 Circular_arc_2;
   typedef typename BK::Line_arc_2                                     Line_arc_2;
 
 public:
-
-  typedef typename CK_Do_overlap_2::result_type result_type;
-
   using Base::operator();
 
 private:
-
   template <class Arc_2>
-  result_type
+  Boolean
   _do_overlap_2(const Arc_2 &a, const Arc_2 &b) const
   {
     Bbox_2 bb1=a.bbox(),bb2=b.bbox();
@@ -424,10 +399,8 @@ private:
     return false;
   }
 
-
 public:
-
+  Boolean
-  result_type
   operator()( const Circular_arc_2 &a , const Circular_arc_2 &b ) const
   {
     CGAL_precondition( a.is_x_monotone());
@@ -435,28 +408,26 @@ public:
     return _do_overlap_2(a,b);
   }
 
-  result_type
+  Boolean
   operator()( const Line_arc_2 &a ,
               const Line_arc_2 &b ) const
   {  return _do_overlap_2(a,b);}
 
-  result_type
+  Boolean
   operator()( const Circular_arc_2 & ,
               const Line_arc_2 & ) const
   {  return false;}
 
-  result_type
+  Boolean
   operator()( const Line_arc_2 & ,
               const Circular_arc_2 & ) const
   {  return false;}
 
 };
 
-
 template < class BK >
 class Intersect_2 : public BK::Circular_kernel:: template Base< BK >::Type::Intersect_2
 {
-public:
   typedef typename BK::Circular_kernel::
     template Base< BK >::Type::Intersect_2      CK_Intersect_2;
 
@@ -466,6 +437,7 @@ public:
   typedef typename BK::Circle_2                 Circle;
   typedef typename BK::Line_2                   Line_2;
 
+public:
   using CK_Intersect_2::operator();
 
   template < class OutputIterator >

Circular_kernel_3/include/CGAL/Circular_kernel_3/function_objects_polynomial_sphere.h

@@ -42,21 +42,27 @@ namespace SphericalFunctors {
 
 #define CGAL_SPHERICAL_KERNEL_MACRO_FUNCTOR_COMPARE_(V)\
 template < class SK > \
-  class Compare_ ##V## _3: public SK::Linear_kernel::Compare_ ##V## _3{\
+  class Compare_ ##V## _3 {\
+    /*: public SK::Linear_kernel::Compare_ ##V## _3{*/\
+    typedef typename SK::Comparison_result Comparison_result;\
     typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;\
     typedef typename SK::Point_3 Point_3;\
+    typedef typename SK::Linear_kernel::Compare_ ##V## _3 Linear_Compare_ ##V## _3;\
   public:\
-    typedef  typename SK::Linear_kernel::Compare_ ##V## _3::result_type result_type;\
+    template <typename A, typename B> \
-    using SK::Linear_kernel::Compare_ ##V## _3::operator();\
+    Comparison_result\
-    result_type\
+    operator()(const A& a, const B& b) const\
+    { return Linear_Compare_ ##V## _3()(a, b); }\
+    /*using SK::Linear_kernel::Compare_ ##V## _3::operator();*/\
+    Comparison_result\
     operator() (const Circular_arc_point_3 &p0,\
                 const Circular_arc_point_3 &p1) const\
     { return SphericalFunctors::compare_ ##V <SK>(p0, p1); }\
-    result_type\
+    Comparison_result\
     operator() (const Circular_arc_point_3 &p0,\
                 const Point_3 &p1) const\
     { return SphericalFunctors::compare_ ##V <SK>(p0, p1); }\
-    result_type\
+    Comparison_result\
     operator() (const Point_3 &p0,\
                 const Circular_arc_point_3 &p1) const\
     { return SphericalFunctors::compare_ ##V <SK>(p0, p1); }\
@@ -68,6 +74,8 @@ template < class SK > \
   CGAL_SPHERICAL_KERNEL_MACRO_FUNCTOR_COMPARE_(xy)
   CGAL_SPHERICAL_KERNEL_MACRO_FUNCTOR_COMPARE_(xyz)
 
+#undef CGAL_SPHERICAL_KERNEL_MACRO_FUNCTOR_COMPARE_
+
   template <class SK>
   class Compute_circular_x_3
   {
@@ -103,11 +111,9 @@ template < class SK > \
 
   template < class SK >
   class Equal_3
-    : public SK::Linear_kernel::Equal_3
+    // : public SK::Linear_kernel::Equal_3
   {
-    typedef typename SK::Linear_kernel LK;
+    typedef typename SK::Boolean Boolean;
-    typedef typename LK::Equal_3 LK_Equal_3;
-
     typedef typename SK::Point_3 Point_3;
     typedef typename SK::Vector_3 Vector_3;
     typedef typename SK::Direction_3 Direction_3;
@@ -125,35 +131,39 @@ template < class SK > \
     typedef typename SK::Line_arc_3               Line_arc_3;
     typedef typename SK::Circular_arc_3           Circular_arc_3;
 
+    typedef typename SK::Linear_kernel::Equal_3 Linear_equal_3;
+
   public:
+    // using SK::Linear_kernel::Equal_3::operator();
 
-    typedef typename SK::Linear_kernel::Equal_3::result_type result_type;
+    template <typename A, typename B>
+    Boolean
+    operator()(const A& a, const B& b) const
+    { return Linear_equal_3()(a, b); }
 
-    using SK::Linear_kernel::Equal_3::operator();
+    Boolean
-
-    result_type
     operator() (const Circular_arc_point_3 &c0,
                 const Circular_arc_point_3 &c1) const
     { return SphericalFunctors::equal<SK>(c0, c1); }
 
-    result_type
+    Boolean
     operator() (const Circular_arc_point_3 &c0,
                 const Point_3 &c1) const
     { return SphericalFunctors::equal<SK>(c0, Circular_arc_point_3(c1)); }
 
-    result_type
+    Boolean
     operator() (const Point_3 &c0,
                 const Circular_arc_point_3 &c1) const
     { return SphericalFunctors::equal<SK>(Circular_arc_point_3(c0), c1); }
 
     // Our Line_arc_3 dont have orientation
-    result_type
+    Boolean
     operator() (const Line_arc_3 &l0,
                 const Line_arc_3 &l1) const
     { return SphericalFunctors::equal<SK>(l0, l1); }
 
     // Our Circular_arc_3 dont have orientation (as parameter)
-    result_type
+    Boolean
     operator() (const Circular_arc_3 &c0,
                 const Circular_arc_3 &c1) const
     { return SphericalFunctors::equal<SK>(c0, c1); }
@@ -175,29 +185,26 @@ template < class SK > \
     typedef typename Circular_arc_point_3::Root_for_spheres_2_3  Root_for_spheres_2_3;
 
   public:
-    typedef  Circular_arc_point_3 result_type;
+    Circular_arc_point_3
-
-    result_type
     operator()(void)
     { return Rep(); }
 
-    result_type
+    Circular_arc_point_3
     operator()(const Root_of_2 & x,
                const Root_of_2 & y,
-                 const Root_of_2 & z
+               const Root_of_2 & z) const
-                 ) const
     { return Rep(x,y,z); }
 
-    result_type
+    Circular_arc_point_3
     operator()(const Root_for_spheres_2_3 & np) const
     { return Rep(np); }
 
-    result_type
+    Circular_arc_point_3
     operator()(const Point_3 & p) const
     { return Rep(p); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Sphere_3 & s1,
                const Sphere_3 & s2,
                const Sphere_3 & s3,
@@ -205,7 +212,7 @@ template < class SK > \
     { return Rep(s1,s2,s3,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Plane_3 & p,
                const Sphere_3 & s1,
                const Sphere_3 & s2,
@@ -213,7 +220,7 @@ template < class SK > \
     { return Rep(p,s1,s2,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Sphere_3 & s1,
                const Plane_3 & p,
                const Sphere_3 & s2,
@@ -221,7 +228,7 @@ template < class SK > \
     { return Rep(p,s1,s2,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Sphere_3 & s1,
                const Sphere_3 & s2,
                const Plane_3 & p,
@@ -229,7 +236,7 @@ template < class SK > \
     { return Rep(p,s1,s2,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Plane_3 & p1,
                const Plane_3 & p2,
                const Sphere_3 & s,
@@ -237,7 +244,7 @@ template < class SK > \
     { return Rep(p1,p2,s,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Plane_3 & p1,
                const Sphere_3 & s,
                const Plane_3 & p2,
@@ -245,7 +252,7 @@ template < class SK > \
     { return Rep(p1,p2,s,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Sphere_3 & s,
                const Plane_3 & p1,
                const Plane_3 & p2,
@@ -253,42 +260,42 @@ template < class SK > \
     { return Rep(p1,p2,s,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Line_3 & l,
                const Sphere_3 & s,
                const bool less_xyz = true) const
     { return Rep(l,s,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Sphere_3 & s,
                const Line_3 & l,
                const bool less_xyz = true) const
     { return Rep(l,s,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Circle_3 & c,
                const Sphere_3 & s,
                const bool less_xyz = true) const
     { return Rep(c,s,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Sphere_3 & s,
                const Circle_3 & c,
                const bool less_xyz = true) const
     { return Rep(c,s,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Circle_3 & c,
                const Plane_3 & p,
                const bool less_xyz = true) const
     { return Rep(c,p,less_xyz); }
 
     // Not Documented
-    result_type
+    Circular_arc_point_3
     operator()(const Plane_3 & p,
                const Circle_3 & c,
                const bool less_xyz = true) const
@@ -466,8 +473,6 @@ template < class SK > \
     { return c.rep().supporting_plane(); }
   };
 
-
-
   template <class SK>
   class Construct_line_3
   {
@@ -611,43 +616,41 @@ template < class SK > \
     typedef typename Line_arc_3::Rep               Rep;
 
   public:
-    typedef Line_arc_3   result_type;
+    Line_arc_3
-
-    result_type
     operator()(void) const
     { return Rep(); }
 
-    result_type
+    Line_arc_3
     operator()(const Line_3 &l,
                const Circular_arc_point_3 &s,
                const Circular_arc_point_3 &t) const
     { return Rep(l,s,t); }
 
-    result_type
+    Line_arc_3
     operator()(const Point_3 &s,
                      const Point_3 &t) const
     { return Rep(s,t); }
 
-    result_type
+    Line_arc_3
     operator()(const Segment_3 &s) const
     { return Rep(s); }
 
     // Not Documented
-    result_type
+    Line_arc_3
     operator()(const Line_3 &l,
                const Sphere_3 &s,
                bool less_xyz_first = true) const
     { return Rep(l,s,less_xyz_first); }
 
     // Not Documented
-    result_type
+    Line_arc_3
     operator()(const Sphere_3 &s,
                const Line_3 &l,
                bool less_xyz_first = true) const
     { return Rep(l,s,less_xyz_first); }
 
     // Not Documented
-    result_type
+    Line_arc_3
     operator()(const Line_3 &l,
                const Sphere_3 &s1, bool less_xyz_s1,
                const Sphere_3 &s2, bool less_xyz_s2) const
@@ -655,7 +658,7 @@ template < class SK > \
                    s2,less_xyz_s2); }
 
     // Not Documented
-    result_type
+    Line_arc_3
     operator()(const Sphere_3 &s1, bool less_xyz_s1,
                const Sphere_3 &s2, bool less_xyz_s2,
                const Line_3 &l) const
@@ -663,14 +666,14 @@ template < class SK > \
                    s2,less_xyz_s2); }
 
     // Not Documented
-    result_type
+    Line_arc_3
     operator()(const Line_3 &l,
                const Plane_3 &p1,
                const Plane_3 &p2) const
     { return Rep(l,p1,p2); }
 
     // Not Documented
-    result_type
+    Line_arc_3
     operator()(const Plane_3 &p1,
                const Plane_3 &p2,
                const Line_3 &l) const
@@ -694,56 +697,55 @@ template < class SK > \
     typedef typename SK::Circular_arc_3                Circular_arc_3;
     typedef typename SK::Kernel_base::Circular_arc_3   RCircular_arc_3;
     typedef typename Circular_arc_3::Rep               Rep;
-  public:
-    typedef Circular_arc_3   result_type;
 
-    result_type
+  public:
+    Circular_arc_3
     operator()(void) const
     { return Rep(); }
 
-    result_type
+    Circular_arc_3
     operator()(const Circle_3 &c) const
     { return Rep(c); }
 
-    result_type
+    Circular_arc_3
     operator()(const Circle_3 &c,const Circular_arc_point_3& pt) const
     { return Rep(c,pt); }
 
-    result_type
+    Circular_arc_3
     operator()(const Circle_3 &l,
                const Circular_arc_point_3 &s,
                const Circular_arc_point_3 &t) const
     { return Rep(l,s,t); }
 
     // Not Documented
-    result_type
+    Circular_arc_3
     operator()(const Circle_3 &c,
                const Sphere_3 &s1, bool less_xyz_s1,
                const Sphere_3 &s2, bool less_xyz_s2) const
     { return Rep(c,s1,less_xyz_s1,s2,less_xyz_s2); }
 
     // Not Documented
-    result_type
+    Circular_arc_3
     operator()(const Sphere_3 &s1, bool less_xyz_s1,
                const Sphere_3 &s2, bool less_xyz_s2,
                const Circle_3 &c) const
     { return Rep(c,s1,less_xyz_s1,s2,less_xyz_s2); }
 
     // Not Documented
-    result_type
+    Circular_arc_3
     operator()(const Circle_3 &c,
                const Plane_3 &p1, bool less_xyz_p1,
                const Plane_3 &p2, bool less_xyz_p2) const
     { return Rep(c,p1,less_xyz_p1,p2,less_xyz_p2); }
 
     // Not Documented
-    result_type
+    Circular_arc_3
     operator()(const Plane_3 &p1, bool less_xyz_p1,
                const Plane_3 &p2, bool less_xyz_p2,
                const Circle_3 &c) const
     { return Rep(c,p1,less_xyz_p1,p2,less_xyz_p2); }
 
-    result_type
+    Circular_arc_3
     operator()(const Point_3 &begin,
                const Point_3 &middle,
                const Point_3 &end) const
@@ -755,13 +757,9 @@ template < class SK > \
   class Construct_circular_min_vertex_3
   {
     typedef typename SK::Line_arc_3                Line_arc_3;
-    typedef typename SK::Circular_arc_point_3      Circular_arc_point_3;
 
   public:
-
+    decltype(auto) operator() (const Line_arc_3& a) const
-    typedef const Circular_arc_point_3& result_type;
-
-    result_type operator() (const Line_arc_3 & a) const
     { return (a.rep().lower_xyz_extremity()); }
 
   };
@@ -770,13 +768,9 @@ template < class SK > \
   class Construct_circular_max_vertex_3
   {
     typedef typename SK::Line_arc_3                Line_arc_3;
-    typedef typename SK::Circular_arc_point_3      Circular_arc_point_3;
 
   public:
-
+    decltype(auto) operator() (const Line_arc_3& a) const
-    typedef const Circular_arc_point_3& result_type;
-
-    result_type operator() (const Line_arc_3 & a) const
     { return (a.rep().higher_xyz_extremity()); }
 
   };
@@ -786,16 +780,12 @@ template < class SK > \
   {
     typedef typename SK::Line_arc_3                Line_arc_3;
     typedef typename SK::Circular_arc_3            Circular_arc_3;
-    typedef typename SK::Circular_arc_point_3      Circular_arc_point_3;
 
   public:
-
+    decltype(auto) operator() (const Line_arc_3& a) const
-    typedef const Circular_arc_point_3& result_type;
-
-    result_type operator() (const Line_arc_3 & a) const
     { return (a.rep().source()); }
 
-    result_type operator() (const Circular_arc_3 & a) const
+    decltype(auto) operator() (const Circular_arc_3& a) const
     { return (a.rep().source()); }
 
   };
@@ -804,25 +794,22 @@ template < class SK > \
   class Construct_circular_target_vertex_3
   {
     typedef typename SK::Line_arc_3                Line_arc_3;
-    typedef typename SK::Circular_arc_point_3      Circular_arc_point_3;
     typedef typename SK::Circular_arc_3            Circular_arc_3;
 
   public:
-
+    decltype(auto) operator() (const Line_arc_3 & a) const
-    typedef const Circular_arc_point_3& result_type;
-
-    result_type operator() (const Line_arc_3 & a) const
     { return (a.rep().target()); }
 
-    result_type operator() (const Circular_arc_3 & a) const
+    decltype(auto) operator() (const Circular_arc_3 & a) const
     { return (a.rep().target()); }
 
   };
 
   template < class SK >
   class Has_on_3
-    : public SK::Linear_kernel::Has_on_3
+    // : public SK::Linear_kernel::Has_on_3
   {
+    typedef typename SK::Boolean                 Boolean;
     typedef typename SK::Point_3                 Point_3;
     typedef typename SK::Sphere_3                Sphere_3;
     typedef typename SK::Plane_3                 Plane_3;
@@ -835,69 +822,73 @@ template < class SK > \
     typedef typename SK::Circular_arc_3          Circular_arc_3;
     typedef typename SK::Circle_3                Circle_3;
 
+    typedef typename SK::Linear_kernel::Has_on_3 Linear_Has_on_3;
 
   public:
-    typedef typename SK::Linear_kernel::Has_on_3::result_type result_type;
+    // using SK::Linear_kernel::Has_on_3::operator();
 
-    using SK::Linear_kernel::Has_on_3::operator();
+    template <typename A, typename B>
+    Boolean
+    operator()(const A& a, const B& b) const
+    { return Linear_Has_on_3()(a, b); }
 
-    result_type
+    Boolean
     operator()(const Sphere_3 &a, const Circular_arc_point_3 &p) const
     { return SphericalFunctors::has_on<SK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Plane_3 &a, const Circular_arc_point_3 &p) const
     { return SphericalFunctors::has_on<SK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Line_3 &a, const Circular_arc_point_3 &p) const
     { return SphericalFunctors::has_on<SK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Circle_3 &a, const Circular_arc_point_3 &p) const
     { return SphericalFunctors::has_on<SK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Line_arc_3 &a, const Circular_arc_point_3 &p,
                const bool already_know_point_on_line = false) const
     { return SphericalFunctors::has_on<SK>(a, p, already_know_point_on_line); }
 
-    result_type
+    Boolean
     operator()(const Line_arc_3 &a, const Point_3 &p,
                const bool already_know_point_on_line = false) const
     { return SphericalFunctors::has_on<SK>(a, p, already_know_point_on_line); }
 
-    result_type
+    Boolean
     operator()(const Plane_3 &p, const Line_arc_3 &a) const
     { return SphericalFunctors::has_on<SK>(p, a); }
 
-    result_type
+    Boolean
     operator()(const Line_3 &a, const Line_arc_3 &p) const
     { return SphericalFunctors::has_on<SK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Circular_arc_3 &a, const Point_3 &p,
                const bool has_on_supporting_circle = false) const
     { return SphericalFunctors::has_on<SK>(a, p, has_on_supporting_circle); }
 
-    result_type
+    Boolean
     operator()(const Circular_arc_3 &a, const Circular_arc_point_3 &p,
                const bool has_on_supporting_circle = false) const
     { return SphericalFunctors::has_on<SK>(a, p, has_on_supporting_circle); }
 
-    result_type
+    Boolean
     operator()(const Sphere_3 &a, const Circular_arc_3 &p) const
     { return SphericalFunctors::has_on<SK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Plane_3 &a, const Circular_arc_3 &p) const
     { return SphericalFunctors::has_on<SK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Circle_3 &a, const Circular_arc_3 &p) const
     { return SphericalFunctors::has_on<SK>(a, p); }
 
-    result_type
+    Boolean
     operator()(const Circular_arc_3 &p, const Circle_3 &a) const
     { return SphericalFunctors::has_on<SK>(p, a); }
 
@@ -905,9 +896,9 @@ template < class SK > \
 
   template < class SK >
   class Do_intersect_3
-    : public SK::Linear_kernel::Do_intersect_3
+    // : public SK::Linear_kernel::Do_intersect_3
   {
-
+    typedef typename SK::Boolean                  Boolean;
     typedef typename SK::Sphere_3                 Sphere_3;
     typedef typename SK::Line_3                   Line_3;
     typedef typename SK::Line_arc_3               Line_arc_3;
@@ -916,20 +907,25 @@ template < class SK > \
     typedef typename SK::Circle_3                 Circle_3;
     typedef typename SK::Circle_3                 Circular_arc_point_3;
 
-  public:
+    typedef typename SK::Linear_kernel::Do_intersect_3 Linear_Do_intersect_3;
-    typedef typename SK::Linear_kernel::Do_intersect_3::result_type result_type;
 
-    using SK::Linear_kernel::Do_intersect_3::operator();
+  public:
+    // using SK::Linear_kernel::Do_intersect_3::operator();
+
+    template <typename A, typename B>
+    Boolean
+    operator()(const A& a, const B& b) const
+    { return Linear_Do_intersect_3()(a, b); }
 
 #define CGAL_SPHERICAL_KERNEL_MACRO_DO_INTERSECTION_3_2(A,B)            \
-    result_type                                                         \
+    Boolean                                                             \
     operator()(const A & c1, const B & c2) const                        \
     { std::vector< typename SK3_Intersection_traits<SK, A, B>::type > res; \
       typename SK::Intersect_3()(c1,c2,std::back_inserter(res));        \
       return !res.empty(); }
 
 #define CGAL_SPHERICAL_KERNEL_MACRO_DO_INTERSECTION_3_3(A,B,C)          \
-    result_type                                                         \
+    Boolean                                                             \
     operator()(const A & c1, const B & c2, const C & c3) const          \
     { std::vector< typename SK3_Intersection_traits<SK, A, B, C>::type > res; \
       typename SK::Intersect_3()(c1,c2,c3,std::back_inserter(res));     \
@@ -987,22 +983,21 @@ template < class SK > \
     typedef typename SK::Circle_3                 Circle_3;
     typedef typename SK::Circular_arc_point_3     Circular_arc_point_3;
 
-  public:
+    typedef typename SK::Linear_kernel::Intersect_3 Linear_Intersect_3;
 
+  public:
     //using SK::Linear_kernel::Intersect_3::operator();
 
-    typedef typename SK::Linear_kernel::Intersect_3 Intersect_linear_3;
+    template <typename A, typename B>
-
-    template<class A, class B>
     decltype(auto)
     operator()(const A& a, const B& b) const{
-      return Intersect_linear_3()(a,b);
+      return Linear_Intersect_3()(a,b);
     }
 
     decltype(auto)
     operator()(const Plane_3& p, const Plane_3& q, const Plane_3& r) const
     {
-      return Intersect_linear_3()(p, q, r);
+      return Linear_Intersect_3()(p, q, r);
     }
 
     template < class OutputIterator >
@@ -1217,18 +1212,17 @@ template < class SK > \
   template < class SK >
   class Do_overlap_3
   {
+    typedef typename SK::Boolean        Boolean;
     typedef typename SK::Line_arc_3     Line_arc_3;
     typedef typename SK::Circular_arc_3 Circular_arc_3;
 
   public:
-    typedef bool         result_type;
+    Boolean
-
-    result_type
     operator() (const Line_arc_3 &l1, const Line_arc_3 &l2,
                 const bool known_equal_supporting_line = false) const
     { return SphericalFunctors::do_overlap<SK>(l1, l2, known_equal_supporting_line); }
 
-    result_type
+    Boolean
     operator() (const Circular_arc_3 &c1, const Circular_arc_3 &c2,
                 const bool known_equal_supporting_circle = false) const
     { return SphericalFunctors::do_overlap<SK>(c1, c2, known_equal_supporting_circle); }
@@ -1243,16 +1237,13 @@ template < class SK > \
     typedef typename SK::Circular_arc_3          Circular_arc_3;
 
   public:
-
+    void
-    typedef void         result_type;
-
-    result_type
     operator()(const Line_arc_3 &l,
                const Circular_arc_point_3 &p,
                Line_arc_3 &ca1, Line_arc_3 &ca2) const
     { return SphericalFunctors::split<SK>(l, p, ca1, ca2); }
 
-    result_type
+    void
     operator()(const Circular_arc_3 &c,
                const Circular_arc_point_3 &p,
                Circular_arc_3 &ca1, Circular_arc_3 &ca2) const
@@ -1262,7 +1253,7 @@ template < class SK > \
 
   template <class SK>
   class Construct_bbox_3
-    : public SK::Linear_kernel::Construct_bbox_3
+    // : public SK::Linear_kernel::Construct_bbox_3
   {
     typedef typename SK::Circular_arc_point_3      Circular_arc_point_3;
     typedef typename SK::Circular_arc_3            Circular_arc_3;
@@ -1275,8 +1266,15 @@ template < class SK > \
     typedef typename SK::Iso_cuboid_3              Iso_cuboid_3;
     typedef typename SK::Line_arc_3                Line_arc_3;
 
+    typedef typename SK::Linear_kernel::Construct_bbox_3 Linear_Construct_bbox_3;
+
   public:
-    using SK::Linear_kernel::Construct_bbox_3::operator();
+    // using SK::Linear_kernel::Construct_bbox_3::operator();
+
+    template<class A>
+    decltype(auto)
+    operator()(const A& a) const
+    { return Linear_Construct_bbox_3()(a); }
 
     decltype(auto) operator() (const Circular_arc_point_3 & c) const
     { return c.rep().bbox(); }
@@ -1291,60 +1289,73 @@ template < class SK > \
 
   template <class SK>
   class Compute_approximate_squared_length_3
-    : public SK::Linear_kernel::Compute_approximate_squared_length_3
+    // : public SK::Linear_kernel::Compute_approximate_squared_length_3
   {
     typedef typename SK::Circle_3                  Circle_3;
     typedef typename SK::Circular_arc_3            Circular_arc_3;
     typedef typename SK::FT                        FT;
 
+    typedef typename SK::Linear_kernel::Compute_approximate_squared_length_3 Linear_Compute_approximate_squared_length_3;
+
   public:
-    typedef double result_type;
+    // using SK::Linear_kernel::Compute_approximate_squared_length_3::operator();
 
-    using SK::Linear_kernel::Compute_approximate_squared_length_3::operator();
+    template<class A>
+    double
+    operator()(const A& a) const
+    { return Linear_Compute_approximate_squared_length_3()(a); }
 
-    result_type operator() (const Circular_arc_3 & c) const
+    double operator() (const Circular_arc_3 & c) const
     { return c.rep().approximate_squared_length(); }
 
   };
 
   template <class SK>
   class Compute_approximate_angle_3
-    : public SK::Linear_kernel::Compute_approximate_angle_3
+    // : public SK::Linear_kernel::Compute_approximate_angle_3
   {
-    typedef typename SK::Point_3                   Point_3;
-    typedef typename SK::Vector_3                  Vector_3;
     typedef typename SK::Circular_arc_3            Circular_arc_3;
-    typedef typename SK::FT                        FT;
+
+    typedef typename SK::Linear_kernel::Compute_approximate_angle_3 Linear_Compute_approximate_angle_3;
 
   public:
-    typedef double result_type;
+    // using SK::Linear_kernel::Compute_approximate_angle_3::operator();
 
-    using SK::Linear_kernel::Compute_approximate_angle_3::operator();
+    template <class... Args>
+    decltype(auto) // the linear kernel has "FT" as return type...
+    operator()(const Args&... args) const
+    { return Linear_Compute_approximate_angle_3()(args...); }
 
-    result_type operator() (const Circular_arc_3 & c) const
+    double operator() (const Circular_arc_3 & c) const
     { return c.rep().approximate_angle(); }
 
   };
 
   template <class SK>
   class Bounded_side_3
-    : public SK::Linear_kernel::Bounded_side_3
+    // : public SK::Linear_kernel::Bounded_side_3
   {
+    typedef typename SK::Bounded_side          Bounded_side;
     typedef typename SK::Sphere_3              Sphere_3;
     typedef typename SK::Circle_3              Circle_3;
     typedef typename SK::Circular_arc_point_3  Circular_arc_point_3;
     typedef typename SK::Point_3               Point_3;
 
+    typedef typename SK::Linear_kernel::Bounded_side_3 Linear_Bounded_side_3;
+
   public:
-    typedef typename SK::Linear_kernel::Bounded_side_3::result_type    result_type;
+    // using SK::Linear_kernel::Bounded_side_3::operator();
 
-    using SK::Linear_kernel::Bounded_side_3::operator();
+    template <typename A, typename B>
+    Bounded_side
+    operator()(const A& a, const B& b) const
+    { return Linear_Bounded_side_3()(a, b); }
 
-    result_type
+    Bounded_side
     operator()( const Sphere_3& s, const Circular_arc_point_3& p) const
     { return SphericalFunctors::bounded_side<SK>(s,p); }
 
-    result_type
+    Bounded_side
     operator()( const Circle_3& c, const Circular_arc_point_3& p) const
     { return SphericalFunctors::bounded_side<SK>(c,p); }
 
@@ -1354,23 +1365,29 @@ template < class SK > \
 
   template <class SK>
   class Has_on_bounded_side_3
-    : public SK::Linear_kernel::Has_on_bounded_side_3
+    // : public SK::Linear_kernel::Has_on_bounded_side_3
   {
+    typedef typename SK::Boolean               Boolean;
     typedef typename SK::Sphere_3              Sphere_3;
     typedef typename SK::Circle_3              Circle_3;
     typedef typename SK::Circular_arc_point_3  Circular_arc_point_3;
     typedef typename SK::Point_3               Point_3;
 
+    typedef typename SK::Linear_kernel::Has_on_bounded_side_3 Linear_Has_on_bounded_side_3;
+
   public:
-    typedef typename SK::Linear_kernel::Has_on_bounded_side_3::result_type    result_type;
+    // using SK::Linear_kernel::Has_on_bounded_side_3::operator();
 
-    using SK::Linear_kernel::Has_on_bounded_side_3::operator();
+    template <typename A, typename B>
+    Boolean
+    operator()(const A& a, const B& b) const
+    { return Linear_Has_on_bounded_side_3()(a, b); }
 
-    result_type
+    Boolean
     operator()( const Sphere_3& s, const Circular_arc_point_3& p) const
     { return SK().bounded_side_3_object()(s,p) == ON_BOUNDED_SIDE; }
 
-    result_type
+    Boolean
     operator()( const Circle_3& c, const Circular_arc_point_3& p) const
     { return SK().bounded_side_3_object()(c,p) == ON_BOUNDED_SIDE; }
 
@@ -1380,87 +1397,93 @@ template < class SK > \
 
   template <class SK>
   class Has_on_unbounded_side_3
-    : public SK::Linear_kernel::Has_on_unbounded_side_3
+    // : public SK::Linear_kernel::Has_on_unbounded_side_3
   {
+    typedef typename SK::Boolean               Boolean;
     typedef typename SK::Sphere_3              Sphere_3;
     typedef typename SK::Circle_3              Circle_3;
     typedef typename SK::Circular_arc_point_3  Circular_arc_point_3;
     typedef typename SK::Point_3               Point_3;
 
+    typedef typename SK::Linear_kernel::Has_on_unbounded_side_3 Linear_Has_on_unbounded_side_3;
+
   public:
-    typedef typename SK::Linear_kernel::Has_on_unbounded_side_3::result_type    result_type;
+    // using SK::Linear_kernel::Has_on_unbounded_side_3::operator();
 
-    using SK::Linear_kernel::Has_on_unbounded_side_3::operator();
+    template <typename A, typename B>
+    Boolean
+    operator()(const A& a, const B& b) const
+    { return Linear_Has_on_unbounded_side_3()(a, b); }
 
-    result_type
+    Boolean
     operator()( const Sphere_3& s, const Circular_arc_point_3& p) const
     { return SK().bounded_side_3_object()(s,p) == ON_UNBOUNDED_SIDE; }
 
-    result_type
+    Boolean
     operator()( const Circle_3& c, const Circular_arc_point_3& p) const
     { return SK().bounded_side_3_object()(c,p) == ON_UNBOUNDED_SIDE; }
 
     // We can maybe optimize it doing the operator() for point_3 too
-
   };
 
   template <class SK>
-  class Is_theta_monotone_3{
+  class Is_theta_monotone_3
+  {
     typename SK::Sphere_3 sphere_;
-  public:
-    typedef bool result_type;
 
+  public:
     Is_theta_monotone_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
 
-    result_type
+    typename SK::Boolean
     operator()(const typename SK::Circular_arc_3& arc) const {
       return SphericalFunctors::is_theta_monotone_3<SK>(arc,sphere_);
     }
   };
 
   template < class SK >
-  class Compare_theta_3{
+  class Compare_theta_3
+  {
+    typedef typename SK::Comparison_result    Comparison_result;
     typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
     typedef typename SK::Vector_3             Vector_3;
 
     typename SK::Sphere_3 sphere_;
 
   public:
-    typedef  CGAL::Comparison_result result_type;
-
     Compare_theta_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
 
-    result_type
+    Comparison_result
     operator() (const Circular_arc_point_3 &p0,
                 const Circular_arc_point_3 &p1) const
     { return SphericalFunctors::compare_theta_of_pts<SK>(p0, p1,sphere_); }
 
-    result_type
+    Comparison_result
     operator() (const Circular_arc_point_3 &p,
                 const Vector_3 &v) const
     { return SphericalFunctors::compare_theta_pt_vector<SK>(p,v,sphere_); }
 
-    result_type
+    Comparison_result
     operator() (const Vector_3 &m1,
                 const Vector_3 &m2) const
     { return SphericalFunctors::compare_theta_vectors<SK>(m1,m2); }
 
-    result_type
+    Comparison_result
     operator() (const Vector_3 &v,const Circular_arc_point_3 &p0) const
     { return CGAL::opposite( SphericalFunctors::compare_theta_pt_vector<SK>(p0, v,sphere_) ); }
   };
 
   template < class SK >
-  class Compare_theta_z_3{
+  class Compare_theta_z_3
+  {
+    typedef typename SK::Comparison_result Comparison_result;
     typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
+
     typename SK::Sphere_3 sphere_;
 
   public:
-    typedef  CGAL::Comparison_result result_type;
-
     Compare_theta_z_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
 
-    result_type
+    Comparison_result
     operator() (const Circular_arc_point_3 &p0,
                 const Circular_arc_point_3 &p1,bool decreasing_z=false) const
     { return SphericalFunctors::compare_theta_z<SK>(p0, p1,sphere_,decreasing_z); }
@@ -1468,7 +1491,8 @@ template < class SK > \
   };
 
   template < class SK >
-  class Make_theta_monotone_3{
+  class Make_theta_monotone_3
+  {
     typename SK::Sphere_3 sphere_;
 
   public:
@@ -1487,16 +1511,18 @@ template < class SK > \
   };
 
   template <class SK>
-  class Compare_z_to_right_3{
+  class Compare_z_to_right_3
+  {
+    typedef typename SK::Comparison_result Comparison_result;
     typedef typename SK::Circular_arc_point_3 Circular_arc_point_3;
     typedef typename SK::Circular_arc_3 Circular_arc_3;
+
     typename SK::Sphere_3 sphere_;
 
   public:
-    typedef  CGAL::Comparison_result result_type;
     Compare_z_to_right_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
 
-    result_type
+    Comparison_result
     operator()(const Circular_arc_3& arc1,const Circular_arc_3& arc2,const Circular_arc_point_3& pt,bool do_to_the_left=false){
       CGAL_kernel_precondition(SK().has_on_3_object()(sphere_,arc1));
       CGAL_kernel_precondition(SK().has_on_3_object()(sphere_,arc2));
@@ -1519,14 +1545,16 @@ template < class SK > \
   };
 
   template <class SK>
-  class Compare_z_at_theta_3{
+  class Compare_z_at_theta_3
+  {
+    typedef typename SK::Comparison_result Comparison_result;
+
     typename SK::Sphere_3 sphere_;
 
   public:
-    typedef  CGAL::Comparison_result result_type;
     Compare_z_at_theta_3(const typename SK::Sphere_3& sphere):sphere_(sphere){}
 
-    result_type
+    Comparison_result
     operator()( const typename SK::Circular_arc_3& arc1,
                 const typename SK::Circular_arc_3& arc2,
                 const typename SK::Vector_3& m) const
@@ -1534,7 +1562,7 @@ template < class SK > \
       return SphericalFunctors::compare_z_at_theta_arcs<SK>(arc1,arc2,m,sphere_);
     }
 
-    result_type
+    Comparison_result
     operator()(const typename SK::Circular_arc_point_3& point,
                const typename SK::Circular_arc_3& arc) const
     {

Circular_kernel_3/include/CGAL/Circular_kernel_3/internal_functions_on_sphere_3.h

@@ -85,7 +85,7 @@ namespace CGAL {
 
     template < class SK >
     inline
-    typename SK::Linear_kernel::Bounded_side_3::result_type
+    typename SK::Bounded_side
     bounded_side(const typename SK::Sphere_3 &s,
                  const typename SK::Circular_arc_point_3 &p) {
       typedef typename SK::Algebraic_kernel Algebraic_kernel;
@@ -99,7 +99,7 @@ namespace CGAL {
 
     template < class SK >
     inline
-    typename SK::Linear_kernel::Bounded_side
+    typename SK::Bounded_side
     bounded_side(const typename SK::Circle_3 &c,
                  const typename SK::Circular_arc_point_3 &p) {
       typedef typename SK::Algebraic_kernel Algebraic_kernel;

Circular_kernel_3/include/CGAL/Spherical_kernel_intersections.h

@@ -46,7 +46,7 @@ intersection(const A <K> &c1, const B <K> &c2, OutputIterator res) \
 } \
 template <class K> \
 inline \
-bool \
+typename K::Boolean \
 do_intersect(const A <K> &c1, const B <K> &c2) \
 { \
   return typename K::Do_intersect_3()(c1, c2); \
@@ -61,7 +61,7 @@ intersection(const A <K> &c1, const B <K> &c2, const C <K> &c3, OutputIterator r
 } \
 template <class K> \
 inline \
-bool \
+typename K::Boolean \
 do_intersect(const A <K> &c1, const B <K> &c2, const C <K> &c3) \
 { \
   return typename K::Do_intersect_3()(c1, c2, c3); \

NewKernel_d/include/CGAL/NewKernel_d/Cartesian_static_filters.h

@@ -22,6 +22,8 @@ namespace CGAL {
 namespace SFA { // static filter adapter
 // Note that this would be quite a bit simpler without stateful kernels
 template <class Base_,class R_> struct Adapter_2 {
+        typedef typename Get_type<R_, Orientation_tag>::type Orientation;
+        typedef typename Get_type<R_, Oriented_side_tag>::type Oriented_side;
         typedef typename Get_type<R_, Point_tag>::type        Point;
         typedef typename Get_functor<R_, Compute_point_cartesian_coordinate_tag>::type CC;
         typedef typename Get_functor<Base_, Orientation_of_points_tag>::type Orientation_base;