Order Totals Tutorial

The concise result vocabulary: the result { } computation expression, its accumulating result.list { } / result.array { } variants, and the lightweight admission functions (okIf, failIf, require, orError, mapError). Optional and opt-in, in the same shape as Reified.DataDSL, Reified.ConstraintDSL, and Reified.SchemaDSL: open Reified.Result for Result, then open Reified.ResultDSL for this vocabulary. Deliberately small: generic combinators such as map, bind, orElse, tap, and the traversal helpers stay qualified as Result.map, Result.bind, and so on.

A string that is not null, empty, or whitespace.

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

A list that contains at least one item. The case is public: non-emptiness is carried by the representation rather than by a checked constructor, so head, last, reduce, min, and max are total and pattern matching is available to callers.

A finite double between zero and one inclusive. The only type in this package closed under multiplication: a product of two values in [0, 1] is always in [0, 1], with no overflow to guard against. It is not closed under addition — 0.7 + 0.7 leaves the range — so add is deliberately absent in favour of saturatingAdd and complement.

An inclusive range of ordered values where Lower <= Upper. An interval is always inhabited. Emptiness is represented by Interval option, which is what intersect returns, rather than by a second type — carrying a possibly-empty interval would double every operation without making any of them total. The two ends are named for their roles as bounds, not for a traversal: an interval has no direction, and between 5 1 equals between 1 5. Wire formats that read better as start/end choose those field names at the schema, which is independent of these members — see RefinedSchemas.dateRange. The invariant assumes the value type is totally ordered. float and float32 are not: NaN compares false against everything, so between nan x cannot order its arguments and yields an interval whose bounds are inverted. Use Interval<FiniteFloat>, which excludes NaN by construction, or create, which rejects the pair. This is the same defect exists to remove.

Represents a point in time, typically expressed as a date and time of day, relative to Coordinated Universal Time (UTC).

The fail-fast result { } computation expression.

Smart constructors for built-in refined values, and the refinements behind them. Text, Character, Collection, and Choice are nested here rather than declared beside Refine. Each names a concept general enough to shadow something a caller already has in scope, and none of them is a companion to a type this package exports, so there is nothing to gain from the type-and-module pairing that keeps NonBlankString and DistinctList at the top level.

Creates, executes, composes, and inspects constraints.

Runs a constraint, returning why the value failed. let retryCount = Constraint.between 0 10 42 |> Constraint.check retryCount |> Result.mapError Violation.render

Requires a value strictly greater than the supplied bound. let quantity : Constraint<int> = Constraint.greaterThan 0

Smart constructors for built-in refined values, and the refinements behind them. Text, Character, Collection, and Choice are nested here rather than declared beside Refine. Each names a concept general enough to shadow something a caller already has in scope, and none of them is a companion to a type this package exports, so there is nothing to gain from the type-and-module pairing that keeps NonBlankString and DistinctList at the top level.

The type of immutable singly-linked lists. See the module for further operations related to lists. Use the constructors [] and :: (infix) to create values of this type, or the notation [1; 2; 3]. Use the values in the List module to manipulate values of this type, or pattern match against the values directly. See also F# Language Guide - Lists.

Operations over proportions between zero and one.

Admits a proportion, rejecting anything outside [0, 1] including NaN.

Represents a double-precision floating-point number.

Represents a value that is not a number (). This field is constant.

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

The type of immutable singly-linked lists. See the module for further operations related to lists. Use the constructors [] and :: (infix) to create values of this type, or the notation [1; 2; 3]. Use the values in the List module to manipulate values of this type, or pattern match against the values directly. See also F# Language Guide - Lists.

The fail-fast result { } computation expression.

Smart constructors for built-in refined values, and the refinements behind them. Text, Character, Collection, and Choice are nested here rather than declared beside Refine. Each names a concept general enough to shadow something a caller already has in scope, and none of them is a companion to a type this package exports, so there is nothing to gain from the type-and-module pairing that keeps NonBlankString and DistinctList at the top level.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Fail-fast helpers over the standard F# Result type.

Maps each value with a result-returning function, stopping at the first error. Takes any sequence and always produces a list. Traversal stops at the first error, so later mappings do not run. Use one of the accumulating builders when every error should be reported. [ "1"; "2" ] |> Result.traverse parseInt // Ok [ 1; 2 ]

Binds a result to the next fail-fast operation.

Operations over proportions between zero and one.

Admits a proportion, rejecting anything outside [0, 1] including NaN.

Operations over inclusive ranges of ordered values.

Builds an interval from a pair the caller asserts is already ordered, failing when it is not. Use this at a boundary, where an inverted pair is a caller error worth reporting rather than silently repairing; use between when either order is acceptable input.

Initializes a new instance of the structure using the specified year, month, day, hour, minute, second, and offset. The year (1 through 9999). The month (1 through 12). The day (1 through the number of days in ). The hours (0 through 23). The minutes (0 through 59). The seconds (0 through 59). The time's offset from Coordinated Universal Time (UTC). does not represent whole minutes. is less than one or greater than 9999. -or- is less than one or greater than 12. -or- is less than one or greater than the number of days in . -or- is less than zero or greater than 23. -or- is less than 0 or greater than 59. -or- is less than 0 or greater than 59. -or- is less than -14 hours or greater than 14 hours. -or- The property is earlier than DateTimeOffset.MinValue or later than DateTimeOffset.MaxValue.

Represents a time interval.

Represents the zero value. This field is read-only.

Initializes a new instance of the structure using the specified year, month, day, hour, minute, second, and offset. The year (1 through 9999). The month (1 through 12). The day (1 through the number of days in ). The hours (0 through 23). The minutes (0 through 59). The seconds (0 through 59). The time's offset from Coordinated Universal Time (UTC). does not represent whole minutes. is less than one or greater than 9999. -or- is less than one or greater than 12. -or- is less than one or greater than the number of days in . -or- is less than zero or greater than 23. -or- is less than 0 or greater than 59. -or- is less than 0 or greater than 59. -or- is less than -14 hours or greater than 14 hours. -or- The property is earlier than DateTimeOffset.MinValue or later than DateTimeOffset.MaxValue.

Represents a time interval.

Represents the zero value. This field is read-only.

Operations over inclusive ranges of ordered values.

Builds the smallest interval containing both values, ordering them as needed. Total — this is the constructor to reach for first. Requires a total order. With float or float32, a NaN argument cannot be ordered against anything and produces inverted bounds; prefer Interval<FiniteFloat> or create there.

Operations over proportions between zero and one.

Restricts any double into [0, 1]. Total, including for NaN, which clamps to zero because it has no meaningful position in the range.

Converts the argument to System.Decimal using a direct conversion for all primitive numeric types. For strings, the input is converted using UInt64.Parse() with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. The input value. The converted decimal. decimal "42.23" // evaluates to 42.23M decimal 0xff // evaluates to 255M decimal -10 // evaluates to -10M

Overloaded multiplication operator The first parameter. The second parameter. The result of the operation. 8 * 6 // Evaluates to 48

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Operations over lists that carry their non-emptiness in the type.

Applies a mapping to every item. Non-emptiness is preserved.

Combines every item with an associative operation. Total — no seed required.

Overloaded addition operator The first parameter. The second parameter. The result of the operation. 2 + 2 // Evaluates to 4 "Hello " + "Word" // Evaluates to "Hello World"

Operations over proportions between zero and one.

Returns the distance to one. Total and closed. An involution only up to floating-point rounding: the round trip is exact for dyadic values such as 0.25, but 1 - (1 - 0.3) is not 0.3 in IEEE 754. Compare with a tolerance rather than for equality.

Overloaded multiplication operator The first parameter. The second parameter. The result of the operation. 8 * 6 // Evaluates to 48

Converts the argument to System.Decimal using a direct conversion for all primitive numeric types. For strings, the input is converted using UInt64.Parse() with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. The input value. The converted decimal. decimal "42.23" // evaluates to 42.23M decimal 0xff // evaluates to 255M decimal -10 // evaluates to -10M

Returns the underlying value.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Operations over lists that carry their non-emptiness in the type.

Returns the item with the largest projected key. Total.

Returns the number of items as a plain int, matching List.length.

Averages a projection of the items. Total, for the same reason as average.

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Sorts the given list in descending order using keys given by the given projection. Keys are compared using . This is a stable sort, i.e. the original order of equal elements is preserved. The function to transform the list elements into the type to be compared. The input list. The sorted list. let input = ["a"; "bbb"; "cccc"; "dd"] input |> List.sortByDescending (fun s -> s.Length) Evaluates to ["cccc"; "bbb"; "dd"; "a"].

Returns the first element of the list, or None if the list is empty. The input list. The first element of the list or None. let inputs = [ "banana"; "pear" ] inputs |> List.tryHead Evaluates to Some "banana" let inputs : int list = [] inputs |> List.tryHead Evaluates to None

Returns true if the list contains no elements, false otherwise. The input list. True if the list is empty. [ ] |> List.isEmpty Evaluates to true [ "pear"; "banana" ] |> List.isEmpty Evaluates to false

The representation of "No value"

The representation of "Value of type 'T" The input value. An option representing the value.

Returns the sum of the results generated by applying the function to each element of the list. The function to transform the list elements into the type to be summed. The input list. The resulting sum. let input = [ "aa"; "bbb"; "cc" ] input |> List.sumBy (fun s -> s.Length) Evaluates to 7.

Overloaded division operator The first parameter. The second parameter. The result of the operation. 16 / 2 // Evaluates to 8

Converts the argument to System.Decimal using a direct conversion for all primitive numeric types. For strings, the input is converted using UInt64.Parse() with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. The input value. The converted decimal. decimal "42.23" // evaluates to 42.23M decimal 0xff // evaluates to 255M decimal -10 // evaluates to -10M

Returns the length of the list. The input list. The length of the list. The notation array.Length is preferred. let inputs = [ "a"; "b"; "c" ] inputs |> List.length Evaluates to 3

Represents a point in time, typically expressed as a date and time of day, relative to Coordinated Universal Time (UTC).

Operations over inclusive ranges of ordered values.

Returns whether the value lies within the inclusive bounds.

An inclusive range of ordered values where Lower <= Upper. An interval is always inhabited. Emptiness is represented by Interval option, which is what intersect returns, rather than by a second type — carrying a possibly-empty interval would double every operation without making any of them total. The two ends are named for their roles as bounds, not for a traversal: an interval has no direction, and between 5 1 equals between 1 5. Wire formats that read better as start/end choose those field names at the schema, which is independent of these members — see RefinedSchemas.dateRange. The invariant assumes the value type is totally ordered. float and float32 are not: NaN compares false against everything, so between nan x cannot order its arguments and yields an interval whose bounds are inverted. Use Interval<FiniteFloat>, which excludes NaN by construction, or create, which rejects the pair. This is the same defect exists to remove.

Returns the shared portion of two intervals, or None when they are disjoint. The option is the honest representation of an empty result.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Operations over lists that carry their non-emptiness in the type.

Applies a mapping to every item. Non-emptiness is preserved.

Operations over text known to carry non-whitespace content.

Returns the underlying string value.

Returns the refined value as a standard list.

Operations over lists known to hold no duplicates.

Admits a list, failing when it holds duplicates.

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function to transform elements from the input list. The input list. The list of transformed elements. let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) Evaluates to [ 1; 3; 2 ]

Fail-fast helpers over the standard F# Result type.

Binds a result to the next fail-fast operation.

Builds a map from a distinct list of pairs, failing when two pairs share a key. Distinctness holds over whole pairs, not over keys: [ 1, "a"; 1, "b" ] is a legitimate DistinctList whose entries would collide in a map. The check is what makes the conversion lossless — Map.ofList would silently keep one. For the unconditional guarantee use toSet, where distinct elements always produce a set of the same size.