Simplee.Common 1.0.13

Simplee.Common

Library Simplee.Common v1.0.13 implements common functionality used by all other Simple projects. The namespace of the library is Simplee.

    open Simplee

Here is the main functionality exposed:

1. Active patterns
2. Error types
3. Result monad

Find below more details about each class of functionality.

1. Active Patterns

The library implements different partial and complete active patterns:

1.1. Collections

You can use the following partial active patterns:

1. MemberOf, NotMemberOf - these partial patterns determine if a given item is a member of a given collection.
2. SeqDoesContain, SeqNotContains - these partial patterns determine whether a given collection contains or not a given item.

    let is2Or3 = function
        | MemberOf [2;3] -> "x is a member of the collection"
        | _              -> "x is not a member of the collection"

    let doesContain2 = function
        | SeqContains 2 true -> "ns does contain the item 2"
        | _                  -> "ns does not contain the item 2"

1.2. Compare

You can use the following partial active patterns: EqualToN, LessThanN, LessOrEqualToN, GreaterThanN, GreaterOrEqualThanN.

    let isSmallerThan4 = function
        | LessThanN 4 -> "n is less than 4"
        | _           -> "n is greater or equal than 4"

1.3. Numerals

There are couple of classes of active patterns related to numerals:

1. Negative, NegativeOrZero, Positive, PositiveOrZero - these partial patters compare a given number to 0.
2. Even|Odd - the complete pattern determines whether a given number is even or odd.
3. IsMultipleOfN - this partial pattern determine whether a given number if a multiple of a given pivot N. The library exposes several convenience partial patterns for specific pivot values: IsMultipleOf2, IsMultipleOf3, IsMultipleOf4, IsMultipleOf8, IsMultipleOf10, IsMultipleOf16.

    let isMultipleOf2 = function
        | IsMultipleOf2 -> "n is multiple of 2"
        | _             -> "n is not multiple of 2"


    let isMultipleOf80 = functions
        | IsMultipleOf8 & IsMultipleOf10 -> "n is multiple of 8 and 10"
        | _                              -> "n is not multiple of both 8 and 10"

1.3. String

The library exposes couple of classes of active patterns related to string:

1. IsNullOrWhite, IsAllCaps, IndexOf, StartsWith - the partial pattern determines if a given string is null or empty or if the string has only CAPS.
2. Parsing patterns - these partial patterns can be used in order to attempt parsing a given string and get an integer, or a bool, or a Date value. The patterns are: IsInt, IsBool, IsDate.

    let strToInt = function
        | IsInt n -> "The input string is an integer"
        | _       -> "The input string is not an integer"

2. Error Types

The library implements an error type which is used by all other Simple projects. The error can encapsulate any properties (operates as a property bag).

    /// The property attached to an error
    type ErrProperty =
        | ErrProperty of nm:string * v:ErrValue

    /// The error is a property bag.
    type SError = 
        | ErrSuccess  of id:ErrId * props:ErrProperty list
        | ErrWarning  of id:ErrId * props:ErrProperty list
        | ErrError    of id:ErrId * props:ErrProperty list
        | ErrCritical of id:ErrId * props:ErrProperty list

The library exposes several convenience functions which allow the user create error or success instances.

    let e = 
        1        
        |> eid "AREA"                           // the error identifier (area & id)
        |> err                                  // create an error
        |> erraddkid "corr123"                  // adds the correlation id
        |> erraddloc __SOURCE_FILE__ __LINE__   // adds the location
        |> erraddmsg "testing"                  // adds a message

    // To get the string representation of an error call err2str
    e |> err2str

3. Result Monad

The library exposes several convenience function which can help matching the results: isROk, isRErr. This functions match the active patterns: |IsROk| and |IsRErr|.

Also you can find couple convenience function which extract the value from success results and error from failure results: r2val and r2err