reliance on record types in the design of components, and naming conventions

[smoothdeveloper]

I see record types are used for some components as input parameters, which is great.

I'm wondering if there is incentive to try to harmonise how those record values are going to be initialised from end users.

Some regular idioms are already used:

• having an initial value
• having a constructor function

The first one is always good: to discourage users to take dependency on the exact set of fields in the record type and provide sensible defaults.

The second one, right now, doesn't provide much, IMO, beside one can curry that function, it will still break users if the record definition change, while it is possible to explore design with static methods with tuple form syntax, that would allow extra optional parameters and overloads (despite this is not a silver bullet and also possible pit fall).

I think it is important to settle on a single way to do it for the first one, and consider encouraging tupled form static methods for second one.

Another aspect of the consideration is about naming of fields, all the stuff is heavily geared toward statistics domain model, which draws from notation used in science, academia.

IIRC, there are idioms such as distinguish matrices and vectors based on name in a formula being upper case or lower case, and plenty more conventions.

I believe this library wants to draw from this rather than the .NET design guidelines for this particular aspect.

[bvenn]

Could you give examples for record type inputs within FSharp.Stats. Currently I just can list two: SAM with SAM<'id> and NonLinearRegression.GaussNewton with Model respectively. In both cases, the user does not build the types themselve, but they are created internally (sam) or are predefined (nonlinearregression). There may be more, but they do not come to mind right now 😅

Regarding your second aspect: We currently are working on a solution to refactor the linear algebra module and base everything on tensors, rather than vectors and matrices. In function bodies the naming of let bindings often is based on mathematical notations. Although F# isn't case sensitive, there are conventions that are not always followed in FSharp.Stats. I'm not sure if you make life more difficult for newbies who know the conventions by mixing F# and mathematical notation. During the tensor conversion, your point should be definetley be discussed and applied to all modules.

[smoothdeveloper]

@bvenn, you are right, the records seems to not be constructed by client code, and the considerations I was bringing applies for when client code needs to construct those. In many F# community packages, reliance on records that client code construct has been a pain point and I was a bit preemptive opening the discussion 🙂...

I'm not sure if you make life more difficult for newbies who know the conventions by mixing F# and mathematical notation.

In several other packages in .NET ecosystem that draw from design of libraries that come from other ecosystems, the consensus seems to be to make it look like what the existing users are acquainted with, rather than bringing them to the .NET design guidelines.

https://github.com/DiffSharp/DiffSharp/blob/dev/src/DiffSharp.Core/Tensor.fs
https://github.com/SciSharp/Pandas.NET/blob/master/src/Pandas.NET/DataFrames/DataFrame.drop.cs

It doesn't mean FSharp.Stats would follow this, just considering it should be defining guidelines & aesthetics specific to the project.

I overall feel, adhering to the domain is a greater concern than adhering to the ecosystem, code using FSharp.Stats is going to be domain code, or it would be just a call in the middle of another context to just get a few computations done.

Here is a (maybe incomplete) list of records:

Targets
    Occurrences of 'type .* \= .*\{' in Solution
Found usages  (51 usages found)
    <FSharp.Stats>  (47 usages found)
        Distributions  (17 usages found)
            7 type Normal = {
            11 type Gamma = {
            15 type Beta = {
            19 type F = {
            23 type StudentT = {
            28 type StudentizedRange = {
            35 type LogNormal = {
            39 type MultivariateNormal = {
            43 type Exponential = {
            46 type Uniform = {
            50 type Chi = {
            53 type ChiSquared = {
            56 type Bernoulli = {
            59 type Binomial = {
            63 type NegativeBinomial = {
            67 type Hypergeometric = {
            75 type Poisson = {
        Fitting  (2 usages found)
            12 type SumOfSquares = {
            36 type SolverOptions = {
        Interpolation  (2 usages found)
            12 type SplineCoefficients = {
            9 type LinearSplineCoef = {
        ML  (5 usages found)
            Unsupervised  (5 usages found)
                41 type SilhouetteResult = {
                143 type GapStatisticResult = {
                35 type DbscanResult<'a> = {
                20 type KClusteringResult<'a> = {
                12 type PCA = {    
        Optimization  (3 usages found)
            9 type NmConfig = {
            53 type NmInterationResult = {
            107 type StopCriteria = {
        Signal  (6 usages found)
            22 type MorResult = {
            43 type Tag<'t,'v> = {
            55 type PeakFeature = {
            69 type IdentifiedPeak = {
            10 type Ricker = {
            45 type Marr =  {
        Testing  (12 usages found)
            9 type ComparisonMetrics = {
            5 type BinaryConfusionMatrix = {
            98 type MultiLabelConfusionMatrix = {
            39 type HotellingStatistics = { 
            9 type Contrast = { Index            : int    
            162 type CriticalValueContrast = { 
            43 type SAM<'id> when 'id :> System.IComparable = {
            69 type SAMResult<'id> when 'id :> System.IComparable = {
            18 type TTestStatistics = {
            40 type FTestStatistics = {
            65 type ChiSquareStatistics = {
            89 type WilcoxonTestStatistics = {
    7 type SummaryStats<'T> = {
    39 type RunningStats<'T> = {
    18 type Provider<'a> = {
    10 type private testType = {