Crawler recipe

An abbreviation for the CLI type . Basic Types

Builds a map that contains the bindings of the given IEnumerable. The input sequence of key/value pairs. The resulting map. This is an O(n log n) operation, where n is the number of elements in the sequence. Map [ (1, "a"); (2, "b") ] // evaluates to map [(1, "a"); (2, "b")]

An environment containing only a clock, for timed flows with no other services.

Represents an error channel that cannot occur.

Suspends the flow for the specified duration, observing cancellation. The duration to sleep. A flow that completes after the specified delay, or is interrupted if cancelled first.

Represents a time interval.

Returns a that represents a specified number of milliseconds. A number of milliseconds. An object that represents . is less than or greater than . -or- is . -or- is . is equal to .

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

Transforms the successful value of a flow. If the source fails, the is not executed. The original failure cause is preserved, including typed failures, interruption, and defects. Use map for pure value transformations after an effect has succeeded. A function of type 'value -> 'next to transform the successful value. The source flow of type to transform. A new with the transformed success value of type 'next. let flow = Flow.succeed 1 |> Flow.map (fun x -> x + 1)

Contains operations for working with values of type .

Lookup an element in the map, raising KeyNotFoundException if no binding exists in the map. The input key. The input map. Thrown when the key does not exist in the map. The value mapped to the given key. Maps are represented as binary trees so this is an O(log n) operation, where n is the number of bindings in the map. let sample = Map [ (1, "a"); (2, "b") ] sample |> Map.find 1 // evaluates to "a" sample |> Map.find 3 // throws KeyNotFoundException

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.

Specifies whether applicable method overloads include or omit empty substrings from the return value.

The return value does not include array elements that contain an empty string

Contains operations for working with arrays. See also F# Language Guide - Arrays.

Builds a new array that contains the elements of the given array, excluding the first N elements. The number of elements to skip. If negative the full array will be returned as a copy. The input array. A copy of the input array, after removing the first N elements. Thrown when the input array is null. Thrown when count exceeds the number of elements in the array. let inputs = [| "a"; "b"; "c"; "d" |] inputs |> Array.skip 2 Evaluates to [| "c"; "d" |] let inputs = [| "a"; "b"; "c"; "d" |] inputs |> Array.skip 5 Throws ArgumentException. let inputs = [| "a"; "b"; "c"; "d" |] inputs |> Array.skip -1 Evaluates to [| "a"; "b"; "c"; "d" |]. This is an O(n) operation, where n is the length of the array.

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 list from the given array. The input array. The list of elements from the array. let inputs = [| 1; 2; 5 |] inputs |> List.ofArray Evaluates to [ 1; 2; 5 ]. This is an O(n) operation, where n is the length of the array.

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.

Represents a cold stream of values that requires an environment, can fail with a typed error, and supports backpressure. The type of the environment dependency. The type of the failure value. The type of the success values in the stream.

An environment containing only a clock, for timed flows with no other services.

Represents an error channel that cannot occur.

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

Creates a stream from a synchronous sequence of values. The sequence of values to be emitted by the stream. A that yields each value from the sequence. FlowStream.fromSeq [1..10] |> FlowStream.runCollect |> Flow.run ()

Maps values with a continuously replenished, bounded set of child fibers. Results are emitted in completion order. After each result is consumed, the next upstream value starts, so there are no strict batch barriers. At most the configured number of mappings are active or retained. The first failure observed stops the stream; the terminal consumer's child scope interrupts and awaits all remaining mappings before returning.

Creates bounds for parallel Flow and stream operators.

Creates a positive concurrency bound. Thrown when is not positive.

Transforms the successful value of a flow. If the source fails, the is not executed. The original failure cause is preserved, including typed failures, interruption, and defects. Use map for pure value transformations after an effect has succeeded. A function of type 'value -> 'next to transform the successful value. The source flow of type to transform. A new with the transformed success value of type 'next. let flow = Flow.succeed 1 |> Flow.map (fun x -> x + 1)

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

Transforms the successful values of a stream using the provided function. The function to transform each value. The stream whose values should be transformed. A new stream that yields transformed values. let stream = FlowStream.fromSeq [1; 2; 3] |> FlowStream.map (fun n -> n * 2)

Collects all emitted values into a list. stream |> FlowStream.runCollect

Transforms the successful value of a flow. If the source fails, the is not executed. The original failure cause is preserved, including typed failures, interruption, and defects. Use map for pure value transformations after an effect has succeeded. A function of type 'value -> 'next to transform the successful value. The source flow of type to transform. A new with the transformed success value of type 'next. let flow = Flow.succeed 1 |> Flow.map (fun x -> x + 1)

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 using . This is a stable sort, i.e. the original order of equal elements is preserved. This is an O(n log n) operation, where n is the length of the list. The input list. The sorted list. let input = [8; 4; 3; 1; 6; 1] List.sort input Evaluates to [1; 1; 3; 4; 6; 8].

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

Helpers for the clock service.

Creates a live clock backed by and a monotonic timer.

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

The workflow completed successfully.

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.

Immutable sets based on binary trees, where elements are ordered by F# generic comparison. By default comparison is the F# structural comparison function or uses implementations of the IComparable interface on element values. See the module for further operations on sets. All members of this class are thread-safe and may be used concurrently from multiple threads.

An environment containing only a clock, for timed flows with no other services.

Represents an error channel that cannot occur.

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.

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 ] This is an O(n) operation, where n is the length of the list.

Transforms the successful value of a flow. If the source fails, the is not executed. The original failure cause is preserved, including typed failures, interruption, and defects. Use map for pure value transformations after an effect has succeeded. A function of type 'value -> 'next to transform the successful value. The source flow of type to transform. A new with the transformed success value of type 'next. let flow = Flow.succeed 1 |> Flow.map (fun x -> x + 1)

Runs all flows concurrently and returns their values in input order. An empty input succeeds immediately. If any flow fails, remaining flows are interrupted through the same structured parallel composition as zipPar. Scoped resources follow zipPar too: when every flow succeeds they move to the caller's scope; when any fails, all of them are released before sequencePar returns.

For each element of the list, applies the given function. Concatenates all the results and returns the combined list. The function to transform each input element into a sublist to be concatenated. The input list. The concatenation of the transformed sublists. For each positive number in the array we are generating all the previous positive numbers [1..4] |> List.collect (fun x -> [1..x]) The sample evaluates to [1; 1; 2; 1; 2; 3; 1; 2; 3; 4] (added extra spaces for easy reading) This is an O(n) operation, where n is the total length of all resulting sublists.

Returns a new collection containing only the elements of the collection for which the given predicate returns "true" The function to test the input elements. The input list. A list containing only the elements that satisfy the predicate. let input = [1, "Luke"; 2, "Kirk"; 3, "Kenobi"; 4, "Spock"] let isEven x = 0 = x % 2 let isComingFromStarTrek (x,_) = isEven x input |> List.filter isComingFromStarTrek Evaluates to [(2, "Kirk"); (4, "Spock")] This is an O(n) operation, where n is the length of the list.

Negate a logical value. Not True equals False and not False equals True The value to negate. The result of the negation. not (2 + 2 = 5) // Evaluates to true // not is a function that can be compose with other functions let fileDoesNotExist = System.IO.File.Exists >> not

Contains operations for working with values of type .

Evaluates to "true" if the given element is in the given set. The element to test. The input set. True if element is in set. let set = Set.empty.Add(2).Add(3) printfn $"Does the set contain 1? {set.Contains(1))}" The sample evaluates to the following output: Does the set contain 1? false This is an O(log n) operation, where n is the number of elements in the set.

Represents a cold stream of values that requires an environment, can fail with a typed error, and supports backpressure. The type of the environment dependency. The type of the failure value. The type of the success values in the stream.

The empty set for the type 'T. Set.empty<int> Evaluates to set [ ]. This is an O(1) operation.

Creates a cold stream by repeatedly running an effectful state transition. Returns Some(value, nextState) or None when the stream is complete. The state used for the first pull. FlowStream.unfoldFlow (fun n -> Flow.ok (if n < 3 then Some(n, n + 1) else None)) 0

Returns a list that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the list then the later occurrences are discarded. The input list. The result list. let input = [6;1;2;3;1;4;5;5] input |> List.distinct Evaluates to [6; 1; 2; 3; 4; 5]. This is an O(n) operation, where n is the length of the list.

Returns at most N elements in a new list. The maximum number of items to return. The input list. The result list. let inputs = ["a"; "b"; "c"; "d"] inputs |> List.truncate 2 Evaluates to ["a"; "b"] let inputs = ["a"; "b"; "c"; "d"] inputs |> List.truncate 6 Evaluates to ["a"; "b"; "c"; "d"] let inputs = ["a"; "b"; "c"; "d"] inputs |> List.truncate 0 Evaluates to the empty list. This is an O(n) operation, where n is the number of elements to return.

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 This is an O(1) operation.

Same as ok. The value to wrap in a successful flow. A flow that always succeeds with the provided value. let result = Flow.succeed 42 |> Flow.run () // result = Success 42

The representation of "No value"

Computes the union of the two sets. The first input set. The second input set. The union of set1 and set2. let set1 = Set.empty.Add(1).Add(2).Add(3) let set2 = Set.empty.Add(2).Add(3).Add(4) printfn $"The union of {set1} and {set2} is {(Set.union set1 set2)}" The sample evaluates to the following output: The union of set [1; 2; 3] and set [2; 3; 4] is set [1; 2; 3; 4] This is an O(m log n) operation, where m is the number of elements in the first set and n is the number of elements in the second set.

Builds a set that contains the same elements as the given list. The input list. A set containing the elements form the input list. let set = Set.ofList [1, 2, 3] printfn $"The set is {set} and type is {set.GetType().Name}" The sample evaluates to the following output: The set is set [(1, 2, 3)] and type is "FSharpSet`1" This is an O(n log n) operation, where n is the number of elements in the list.

Returns a new list with the distinct elements of the input list which do not appear in the itemsToExclude sequence, using generic hash and equality comparisons to compare values. A sequence whose elements that also occur in the input list will cause those elements to be removed from the result. A list whose elements that are not also in itemsToExclude will be returned. A list that contains the distinct elements of list that do not appear in itemsToExclude. Thrown when itemsToExclude is null. let input = [1, "Kirk"; 2, "Spock"; 3, "Kenobi"] input |> List.except [3, "Kenobi"] Evaluates to [(1, "Kirk"); (2, "Spock")]. [0..10] |> List.except [1..5] // evaluates [0; 6; 7; 8; 9; 10] [1..5] |> List.except [0..10] // evaluates [] This is an O(n+m) operation, where n is the length of the list and m is the length of the items to exclude.

The universal flow { } computation expression.

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

Concatenate two lists. The first list. The second list. The concatenation of the lists. let l1 = ['a'; 'b'; 'c'] let l2 = ['d'; 'e'; 'f'] l1 @ l2 // Evaluates to ['a'; 'b'; 'c'; 'd'; 'e'; 'f'] This is an O(n) operation, where n is the length of the first list.

Maps each value to a stream and concatenates the resulting streams. stream |> FlowStream.collect FlowStream.fromSeq

Creates a stream from a synchronous sequence of values. The sequence of values to be emitted by the stream. A that yields each value from the sequence. FlowStream.fromSeq [1..10] |> FlowStream.runCollect |> Flow.run ()

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

Transforms the successful values of a stream using the provided function. The function to transform each value. The stream whose values should be transformed. A new stream that yields transformed values. let stream = FlowStream.fromSeq [1; 2; 3] |> FlowStream.map (fun n -> n * 2)

Collects all emitted values into a list. stream |> FlowStream.runCollect

Runs the workflow and blocks until the final exit is available. The environment used by the workflow. The workflow to run. The final workflow exit. let exit = workflow |> Flow.run environment

Helpers for the clock service.

Creates a live clock backed by and a monotonic timer.

Represents the final outcome of a workflow execution. The type of the success value. The type of the domain-specific failure value.

The workflow completed successfully.