model trait rename: methods -> functions

Author: ablaom

docs/src/index.md

@@ -36,7 +36,7 @@ probability distributions".  There is no abstract type model hierarchy.
 
 Our preceding remarks notwithstanding, there is, for certain applications involving a
 "target" variable (understood in a rather general way - see below) a clear-cut distinction
-between models, based on the proxy for the target as actually output by the
+between models, based on the proxy for the target that is actually output by the
 model. Probability distributions, confidence intervals and survival functions are examples
 of [Target proxies](@ref). LearnAPI provides a trait for distinguishing such models based
 on the target proxy.
@@ -65,8 +65,8 @@ The following methods, dispatched on model type, are provided:
 - **model traits**, such as `target_proxy(model)`, for promising specific behaviour
 
 There is flexibility about how much of the interface is implemented by a given model
-object `model`. A special trait `methods(model)` declares what has been
-explicitly implemented or overloaded to work with `model`.
+object `model`. A special trait `functions(model)` declares what has been explicitly
+implemented or overloaded to work with `model`, excluding traits.
 
 Since this is a functional-style interface, `fit` returns model `state`, in addition to
 learned parameters, for passing to the optional `update!` and `ingest!` methods. These

docs/src/model_traits.md

@@ -5,18 +5,17 @@ In this table, `Table` and `Continuous` are names owned by the package
 
 | trait                                            | fallback value        | return value  | example |
 |:-------------------------------------------------|:----------------------|:--------------|:--------|
-| [`LearnAPI.ismodel`](@ref)`(model)`              | `false`               | is `true` for any model, as defined in [Models](@ref) | `true` |
-| [`LearnAPI.methods`](@ref)`(model)`  | `()`                  | lists of all overloaded/implemented methods (traits excluded) | `(:fit, :predict)` |
+| [`LearnAPI.functions`](@ref)`(model)`  | `()`                  | implemented LearnAPI functions (traits excluded) | `(:fit, :predict)` |
 | [`LearnAPI.target_proxy`](@ref)`(model)`    | `NamedTuple()`                  | details form of target proxy output | `(; predict=LearnAPI.Distribution()` |
 | [`LearnAPI.position_of_target`](@ref)`(model)`   | `0`                   | † the positional index of the **target** in `data` in `fit(..., data...; metadata)` calls | 2 |
 | [`LearnAPI.position_of_weights`](@ref)`(model)`  | `0`                   | † the positional index of **observation weights** in `data` in `fit(..., data...; metadata)` | 3 |
 | [`LearnAPI.descriptors`](@ref)`(model)`          | `()`                  | lists one or more suggestive model descriptors from `LearnAPI.descriptors()` | (:classifier, :probabilistic) |
 | [`LearnAPI.is_pure_julia`](@ref)`(model)`        | `false`               | is `true` if implementation is 100% Julia code | `true` |
 | [`LearnAPI.pkg_name`](@ref)`(model)`             | "unknown"             | name of package providing core algorithm (may be different from package providing LearnAPI.jl implementation) | "DecisionTree" |
-| [`LearnAPI.doc_url`](@ref)`(model)`               | "unknown"             | url providing documentation of the core algorithm  | "https://en.wikipedia.org/wiki/Decision_tree_learning" |
 | [`LearnAPI.pkg_license`](@ref)`(model)`          | "unknown"             | name of license of package providing core algorithm | "MIT" |
+| [`LearnAPI.doc_url`](@ref)`(model)`               | "unknown"             | url providing documentation of the core algorithm  | "https://en.wikipedia.org/wiki/Decision_tree_learning" |
 | [`LearnAPI.load_path`](@ref)`(model)`            | "unknown"             | a string indicating where the struct `typeof(model)` is defined, beginning with name of package providing implementation | `FastTrees.LearnAPI.DecisionTreeClassifier` |
-| [`LearnAPI.is_wrapper`](@ref)`(model)`          | `false`                | is `true` if one or more hyperparameters are themselves models | `true` |
+| [`LearnAPI.is_wrapper`](@ref)`(model)`          | `false`                | is `true` if one or more properties (fields) are themselves models | `true` |
 | [`LearnAPI.fit_keywords`](@ref)`(model)`        |  `()`                  | tuple of symbols for keyword arguments accepted by `fit` (metadata) | `(:class_weights,)` |
 | [`LearnAPI.human_name`](@ref)`(model)`          | type name with spaces  | human name for the model; should be a noun | "elastic net regressor" |
 | [`LearnAPI.iteration_parameter`](@ref)`(model)` | nothing                | symbolic name of an iteration parameter | :epochs |

docs/src/operations.md

@@ -37,7 +37,7 @@ ŷ, predict_report = LearnAPI.predict(some_model, fitted_params, Xnew)
   [`LearnAPI.predict_joint`](@ref).
 
 - Each operation explicitly implemented or overloaded must be included in the return value
-  of [`LearnAPI.methods`](@ref).
+  of [`LearnAPI.functions`](@ref).
 
 ## Predict or transform?
 

docs/src/reference.md

@@ -56,10 +56,10 @@ required. If a model has other models as hyper-parameters, its
 
 None of the methods described in the linked sections below are compulsory, but any
 implemented or overloaded method that is not a model trait must be added to the return
-value of [`LearnAPI.methods`](@ref), as in
+value of [`LearnAPI.functions`](@ref), as in
 
 ```julia
-LearnAPI.methods(::Type{<SomeModelType}) = (:fit, update!, predict)
+LearnAPI.functions(::Type{<SomeModelType}) = (:fit, update!, predict)
 ```
 
 For examples, see [Anatomy of an Interface](@ref).

src/accessor_functions.jl

@@ -15,7 +15,7 @@ Return the model-specific feature importances of `model`, given `fittted_params`
 => 0.1]`).
 
 The `model` supports feature importances if `:feature_importance in
-LearnAPI.methods(model)`.
+LearnAPI.functions(model)`.
 
 If for some reason a model is sometimes unable to report feature importances, then
 `feature_importances` will return all importances as 0.0, as in `[:gender =>0.0, :height

src/fit_update_ingest.jl

@@ -8,7 +8,7 @@ const DOC_OPERATIONS =
 function DOC_IMPLEMENTED_METHODS(name; overloaded=false)
     word = overloaded ? "overloaded" : "implemented"
     "If $word, include `:$name` in the tuple returned by the "*
-    "[`LearnAPI.methods`](@ref) trait. "
+    "[`LearnAPI.functions`](@ref) trait. "
 end
 
 const DOC_WHAT_IS_DATA =

src/model_traits.jl

@@ -1,18 +1,44 @@
 # There are two types of traits - ordinary traits that an implemenation overloads to make
 # promises of model behaviour, and derived traits, which are never overloaded.
 
+const DERIVED_TRAITS = (:name, :ismodel)
+const ORDINARY_TRAITS = (
+    :functions,
+    :target_proxy,
+    :position_of_target,
+    :position_of_weights,
+    :descriptors,
+    :is_pure_julia,
+    :pkg_name,
+    :pkg_license,
+    :doc_url,
+    :load_path,
+    :is_wrapper,
+    :fit_keywords,
+    :human_name,
+    :iteration_parameter,
+    :fit_data_scitype,
+    :fit_data_type,
+    :fit_observation_scitypes,
+    :fit_observation_types,
+    :input_scitypes,
+    :input_types,
+    :output_scitypes,
+    :output_types,
+)
 
 # # DERIVED TRAITS
 
 name(M::Type) = string(typename(M))
+ismodel(M::Type) = !isempty(functions(M))
 
 
 # # ORDINARY TRAITS
 
-methods() = METHODS = (OPERATIONS..., ACCESSOR_FUNCTIONS...)
+functions() = METHODS = (OPERATIONS..., ACCESSOR_FUNCTIONS...)
 
 """
-   LearnAPI.methods(m)
+   LearnAPI.functions(m)
 
 Return a tuple of symbols, such as `(:fit, :predict)`, corresponding to LearnAPI.jl
 methods implemented for objects having the same type as `m`.
@@ -26,18 +52,15 @@ $DOC_MODEL
 
 # New model implementations
 
-Elements of the returned tuple must come from this list: $(join(string.(methods()), ", ")).
+Elements of the returned tuple must come from this list: $(join(string.(functions()), ", ")).
 
 A new type whose instances are intended to be LearnAPI models can guarantee that by
 subtyping [`LearnAPI.Model`](@ref).
 
 See also [`LearnAPI.Model`](@ref).
 
 """
-methods(::Type) = ()
-
-ismodel(::Any) = false
-ismodel(::Model) = true
+functions(::Type) = ()
 
 target_proxy(::Type) = NamedTuple()
 
@@ -92,7 +115,7 @@ iteration_parameter(::Type) = nothing
 
 fit_data_scitype(::Type) = Union{}
 
-fit_data_types(::Type) = Union{}
+fit_data_type(::Type) = Union{}
 
 fit_observation_scitypes(::Type) = Union{}
 

src/models.jl

@@ -21,11 +21,11 @@ $DOC_MODEL
 
 # New model implementations
 
-Overloading [`LearnAPI.methods`](@ref) for a given type implies a promise that instances
+Overloading [`LearnAPI.functions`](@ref) for a given type implies a promise that instances
 of that type are LearnAPI.jl models in the above sense. If one subtypes `LearnAPI.Model`,
 then this promise automatically holds true.
 
-See also [`LearnAPI.methods`](@ref).
+See also [`LearnAPI.functions`](@ref).
 
 """
 abstract type Model <: MLType end