Function overload pattern

[jingcheng-chen]

I notice that we have another way to write overload function in the project:

 public DistanceTo(
    other: Point3d | Line | Plane,
    limitToFiniteSegment: boolean = false
  ): number {
    if (other instanceof Line)
      return Line.LineLineDistance(this, other, limitToFiniteSegment);
    if (other instanceof Plane)
      return Line.LinePlaneDistance(this, other, limitToFiniteSegment);
    return Line.LinePointDistance(this, other, limitToFiniteSegment);
  }

Whereas in the old code I explicitly seperate overload functions into multiple functions, like:

  /**
   * Sums up a point and a vector, and returns a new point.
   * @param vector A vector.
   * @returns A new point that results from the addition of point and vector.
   */
  public Add(vecotr: Vector3d): Point3d {
    return Point3d.Add(this, vecotr);
  }

  /**
   * Sums up a point and a point, and returns a new point.
   * @param point A point.
   * @returns A new point that results from the addition of point and point.
   */
  public AddPoint(point: Point3d): Point3d {
    return Point3d.AddPoint(this, point);
  }

Now I think it's an interesting discussion which pattern we are going to keep.
At first sight the first method is cleaner for the user. Question is can it handle more complex cases?

What I can think of:

1. What if it returns different types depending on the input? (like point-point->vector, point-vector->point)
2. What if we have different lengths of input arguments?
3. What if some arguments can be undefined?

[jingcheng-chen]

@JonasWard your input is welcome :)

[JonasWard]

I am also really struggling with this! So the way I was thinking about it right now is that it does make sense (is even necessary) to keep these individual, strict type, overload methods around explicitly as static methods, while the instance methods can be more forgiving? Though only when the output data is the same! This I would not change. Eg. for the crossing and intersection of lines, you should check either, not have a method that checks both that then returns the data that is the most relevant.

[jingcheng-chen]

Then I would say we keep the explicit way, which saves us from the type-checking hassle as well.

So the above example we could change to DistanceToPoint, DistanceToLine, DistanceToPlane A bit verbose but logically simpler 😄

We don't have to change it now, just in the future we could follow this rule.

[JonasWard]

or we leave out the instance method itself in its entirety for now? the static methods are already there (:

[jingcheng-chen]

From the user point of view it's still necessary to have the instance functions.

I would point.Add(a).Multiply(b).DistanceTo(c)
instead of Point3d.DistanceTo(Point3d.Multiply(Point3d.Add(point, a), b), c)

[JonasWard]

yes! I agree (: just in the case of the DistanceToPoint, DistanceToLine, DistanceToPlane methods :)

[JonasWard]

I was wondering whether it would make sense for every type of geometric operation to define a separate file, like the Intersection class, but then also for Distance, T / UV Parameter. In the end it will always be the same for all objects: find a tParameter on (an) object(s) and then maybe do something else with it. What if we put all those as static methods in a class. This gives us basically a matrix of geometries that can do a certain operation with specific other geometries. We than implement these static methods as an instance method to the specific geometry with another type of geometry. This way we can avoid having some code duplication by keeping a better overview over more low-level code! In the Operation-Class we could also have a method that takes like DistanceToLineFrom(l: Line, o: <all optional other geometries>)

concrete: add a Distance & Parameter class file with all the static methods that are currently in the geometries. Only keep an instance method in the geometry classes that uses these static methods in the new "Operation" classes

[jingcheng-chen]

I agree with making static Distance, Parameter classes but not convinced with Operation class. In the end I would still like to have line.DistanceTo() function.

One step back and see what does it mean to the current structure. So we will have Distance, Closest, Transform etc?