Transcript Parsing
The objective of this TranscriptParsing.fsx script is to give a few examples
on how to parse html documents with F#. More specifically, we will be attempting
to parse earnings call transcripts from Motley Fool.
Before getting started, lets download the FSharp.Data nuget package using .NET's package manager NuGet:
#r "nuget: FSharp.Data"
open System
open FSharp.Data
Transcript - Url
We can download or parse individual html documents with their url. Since each call transcript will have a different url, we need to find an effective and consistent way to fetch individual urls from motley fool's website. Fortunately, if we take a look at motley fool's front page, we see that all call transcripts are tagged with hyperlinks.
Since the transcripts are tagged with a specific hypertext reference
(href) ("/earnings/call-transcripts"), we can use the CssSelect
method from FSharp Data to find all elements in a given front page
that match the transcript href that we are looking for. After fetching
the urls, we can download any transcript we want as an html document
using the HtmlDocument.Load method, also from FSharp Data.
type FrontPageDocument = HtmlDocument
/// Match html node with "href" attribute and create transcript url
let makeFoolUrl (attrib:HtmlAttribute) =
match attrib.Name(), attrib.Value() with
| "href", stub -> $"https://www.fool.com{stub}"
| _, _ -> failwithf $"Expected href attribute but got {attrib}"
/// Search for transcript urls
let findTranscriptUrls (pageDoc: FrontPageDocument): string [] =
pageDoc.CssSelect("a[href^='/earnings/call-transcripts']")
|> Seq.choose (HtmlNode.tryGetAttribute "href")
|> Seq.map makeFoolUrl
|> Seq.toArray
Lets take a look at the first three call transcript urls CssSelect was able to match:
let exampleFrontPageDoc: FrontPageDocument = HtmlDocument.Load "https://www.fool.com/earnings-call-transcripts/?page=1"
let exampleUrls = findTranscriptUrls exampleFrontPageDoc
/// First three urls
exampleUrls
|> Array.take 3
|> Array.iter (fun xs -> printfn$"{xs}")
|
Transcript - Ticker & Exchange
Apart from using the CssSelect method to search for transcript urls
we can also use it to extract other key information like a company's
ticker and exchange as well as the time and date of the earnings call.
Lets see if we can fetch Tesla's ticker and exchange from its 2021 Q2 earnings call:
type TranscriptDocument = HtmlDocument
/// Tesla transcript html document
let teslaDoc: TranscriptDocument = HtmlDocument.Load "https://www.fool.com/earnings/call-transcripts/2021/07/27/tesla-tsla-q2-2021-earnings-call-transcript/"
teslaDoc.CssSelect("span[class='ticker']")
|
teslaDoc.CssSelect("span[class='ticker']")
|> List.map (fun x -> x.InnerText())
|
teslaDoc.CssSelect("span[class='ticker']")
|> List.map (fun x ->
x.InnerText()
.Trim()
.Replace("(","")
.Replace(")",""))
|> List.distinct
|> List.tryExactlyOne
|
// A function to do the same
let cleanTickerExchangeText (doc:TranscriptDocument) =
doc.CssSelect("span[class='ticker']")
|> Seq.map (fun x ->
x.InnerText()
.Trim()
.Replace("(","")
.Replace(")",""))
|> Seq.distinct
|> Seq.tryExactlyOne
cleanTickerExchangeText teslaDoc
|
Since we are not certain that we'll retrieve both a ticker and an exchange from every single transcript we parse, we can use match expressions and option types to make sure to return only those matches that contain both a valid ticker and exchange.
/// Match inner text from html node to a ticker and exchange
let tryTickerExchange (tickerInfo: string): option<string * string> =
match tickerInfo.Split(":") with
|[|exchange; ticker|] -> Some (ticker, exchange)
| _ -> None
/// Search for ticker and exchange
let findTickerExchange (doc: TranscriptDocument): option<string * string> =
doc
|> cleanTickerExchangeText
|> Option.bind tryTickerExchange
// Tesla ticker and exchange
findTickerExchange teslaDoc
|
Transcript - Date & Time
Taking a closer look at Tesla's earnings transcript page, we can see that right below Tesla's ticker we spot the exact time and date of the earnings call.
Let's see if we can use CssSelect to fetch this information:
Date
/// Format date string
let cleanDate (node: HtmlNode): option<string> =
node.InnerText()
.ToUpperInvariant()
.Replace(".", "")
.Replace(",", "")
.Trim()
.Split(" ")
|> fun dateArr ->
match dateArr with
|[|month; day; year|] -> Some ($"{month.[..2]} {day} {year}")
| _ -> None
/// Search for transcript date
let findDate (doc: TranscriptDocument): option<string>=
doc.CssSelect("span[id='date']")
|> Seq.tryExactlyOne
|> Option.bind cleanDate
/// Date of Tesla's call:
findDate teslaDoc
|
Time
/// Format time string
let cleanTime (node: HtmlNode) =
node.InnerText()
.ToUpperInvariant()
.Replace(".", "")
|> fun txt ->
if (txt.Contains "ET")
then txt.Replace("ET", "").Trim()
else failwithf $"Expected ET timezone but got {txt}"
/// Search for transcript time
let findTime (doc: TranscriptDocument) =
doc.CssSelect("em[id='time']")
|> Seq.tryExactlyOne
|> Option.map cleanTime
/// Time of Tesla's call
findTime teslaDoc
|
DateTime
Now that we have working functions for both the date and time of each call, lets combine these functions together and convert the information we have on the date and time of an earnings call to a DateTime struct :
/// DateTime converter
let convertToDateTime (date: string, time: string): DateTime =
let dateExpr = $"{date} {time}"
let dateFormat = "MMM d yyyy h:mm tt"
DateTime.ParseExact(dateExpr, dateFormat, System.Globalization.CultureInfo.InvariantCulture)
/// Search for and match date and time
let findDateTime (doc: TranscriptDocument): option<DateTime> =
match findDate doc, findTime doc with
| Some date, Some time ->
let dt = convertToDateTime (date, time)
Some dt
| _ -> None
/// Tesla call DateTime
findDateTime teslaDoc
|
Transcript - Paragraphs
The transcript itself can also be easily parsed using the CssSelect() method.
In html, blocks of text or paragraphs are defined with the "
" tag:
let findParagraphs (doc: TranscriptDocument): string [] =
doc.CssSelect("p")
|> Seq.map (fun x -> x.InnerText().Trim())
// Remove empty paragraphs
|> Seq.filter (fun x -> x <> "")
// Skip first 5 paragraphs
|> Seq.skip 5
|> Seq.toArray
let firstCharacters (paragraph: string) =
if paragraph.Length <= 50
then paragraph
else paragraph.[..49] + " ... "
// First two paragraphs
teslaDoc
|> findParagraphs
|> Array.take 5
|> Array.map firstCharacters
|> Array.iteri (printfn "Paragraph %i: %s")
|
Transcript - Fiscal Quarter
Although we have already found a way to fetch the exact time and date of each earnings call, we could also fetch from the title of each transcript the quarter of which each call refers to.
Example titles:
- Microsoft (MSFT) Q4 2021 Earnings Call Transcript
- Tesla (TSLA) Q2 2021 Earnings Call Transcript
- IBM (IBM) Q2 2021 Earnings Call Transcript
We can already see a pattern emerging from the titles:
- CompanyName (CompanyTicker) Q[1,2,3,4] 0000 Earnings Call Transcript
Having idendified this pattern, we can create a Regular Expression Regex) pattern to help us extract the fiscal quarter from each title.
open System.Text.RegularExpressions
/// Regular Expression
let quarterRegex = Regex("Q\d{1}")
/// Extract number from "Q\d{1}"
let getQNumb (q: string): option<int> =
Seq.toArray q
|> fun xs ->
match xs with
| [|q; qNumb|] -> Some (qNumb |> Char.GetNumericValue |> int)
| _ -> None
let findFiscalQuarter (doc: TranscriptDocument): option<int> =
doc.CssSelect("title")
|> Seq.map (fun xs ->
xs.InnerText()
|> quarterRegex.Match
|> fun xs -> xs.Value)
// Check if there is exactly one match
|> Seq.tryExactlyOne
// Convert string to int
|> Option.bind getQNumb
findFiscalQuarter teslaDoc
|
EarnignsCall Record
So far we have worked with individual functions that take in one single argument,
an html transcript document. Since they all work with the TranscriptDocument
type, we can easily combine these functions together to form one single function
that returns all the individual bits of data that we want.
We'll use a record called EarningsCall to hold all our information.
type CallId =
{ Ticker: string
Exchange: string
Date: System.DateTime
FiscalQuarter : int }
type EarningsCall =
{ CallId : CallId
Transcript: string [] }
/// Search for ticker, exchange, date and paragraphs
let parseTrancriptDoc (doc: TranscriptDocument): option<EarningsCall> =
let matchExpr =
findTickerExchange doc,
findDateTime doc,
findFiscalQuarter doc
match matchExpr with
| Some (ticker, exchange),
Some date,
Some fiscalQuarter ->
let callId =
{ Ticker = ticker
Exchange = exchange
Date = date
FiscalQuarter = fiscalQuarter }
Some { CallId = callId
Transcript = findParagraphs doc }
| _ -> None
/// Tesla transcript record
let teslaTranscript = parseTrancriptDoc teslaDoc
teslaTranscript
|> Option.iter(fun xs ->
printfn $"Id:\n{xs.CallId}\n"
printfn $"First 5 paragraphs:"
xs.Transcript
|> Array.truncate 5
|> Array.map firstCharacters
|> Array.iter (printfn "%A"))
|
Now that we have a working function that takes in a TranscriptDocument and
returns a EarningsCall type, lets try to parse all of the transcript urls from
exampleFrontPageDoc.
/// Parsing transcripts from front page
let exampleTranscripts =
exampleFrontPageDoc
|> findTranscriptUrls
|> Array.choose (fun tUrl ->
let doc = HtmlDocument.Load tUrl
parseTrancriptDoc doc)
/// Total number of transcripts
printfn $"N: {exampleTranscripts.Length}"
|
/// First 5 transcripts
exampleTranscripts
|> Array.take 5
|> Array.iter (fun xs ->
let tId = xs.CallId
printfn $"TranscriptId: %4s{tId.Ticker}, %6s{tId.Exchange}, {tId.Date}")
|
Data visualization with Plotly.NET
.NET has several useful libraries, including one dedicated for generating charts. With Plotly.NET you can create all sorts of charts from simple histograms all the way to 3D surface plots. Just like with FSharp Data, we can download Plotly.Net with .NET's package manager, Nuget.
#r "nuget: Plotly.NET, 2.0.0-preview.6"
open Plotly.NET
/// Histogram
let transcriptTimesHistogram =
let callTimes =
exampleTranscripts
|> Array.map (fun xs -> xs.CallId.Date.TimeOfDay.ToString())
|> Array.sort
callTimes
|> Chart.Histogram
|> Chart.withTitle "Earnings calls by time of day (ET)"
|> Chart.withY_AxisStyle "Count"
|> Chart.withSize (750., 500.)
transcriptTimesHistogram |> Chart.Show
Although we are working with a small sample, we can already notice that the time of the earnings calls are varied and that calls occur before market hours, during market hours and even after market hours.
Async methods
let asyncTranscript (url: string) =
let rec loop attempt url =
async {
try
let! transcriptDoc = HtmlDocument.AsyncLoad url
let transcriptRec = parseTrancriptDoc transcriptDoc
return transcriptRec
with e ->
if attempt > 0 then
do! Async.Sleep 2000 // Wait 2 seconds in case we're throttled.
return! loop (attempt - 1) url
else return! failwithf "Failed to request '%s'. Error: %O" url e }
loop 5 url
let asyncPage (n: int) =
let rec loop attempt n =
async {
printfn $"{n}"
let frontPageP = $"https://www.fool.com/earnings-call-transcripts/?page={n}"
try
let! pageDoc = HtmlDocument.AsyncLoad frontPageP
return findTranscriptUrls pageDoc
with e ->
if attempt > 0 then
do! Async.Sleep 2000 // Wait 2 seconds in case we're throttled.
return! loop (attempt - 1) n
else return! failwithf "Failed to request '%s'. Error: %O" frontPageP e }
loop 5 n
Parse Transcript Pages
module Async =
let ParallelThrottled xs = Async.Parallel(xs, 5)
let asyncPages (pages: int list) =
let urls =
pages
|> Seq.map asyncPage
|> Async.ParallelThrottled
|> Async.RunSynchronously
|> Array.collect id
let transcripts =
urls
|> Array.map asyncTranscript
|> Async.ParallelThrottled
|> Async.RunSynchronously
|> Array.choose id
transcripts
// Done
let examplePages = asyncPages [1 .. 5]
Export to json
#r "nuget: Newtonsoft.Json"
open Newtonsoft.Json
Environment.CurrentDirectory <- __SOURCE_DIRECTORY__
let transcriptsToJson (fileName: string) (calls: EarningsCall []) =
JsonConvert.SerializeObject(calls)
|> fun json -> IO.File.WriteAllText(fileName, json)
transcriptsToJson "data-cache/examplePages.json" examplePages
namespace System
Multiple items
namespace FSharp
--------------------
namespace Microsoft.FSharp
namespace FSharp
--------------------
namespace Microsoft.FSharp
Multiple items
namespace FSharp.Data
--------------------
namespace Microsoft.FSharp.Data
namespace FSharp.Data
--------------------
namespace Microsoft.FSharp.Data
type FrontPageDocument = HtmlDocument
Multiple items
module HtmlDocument from FSharp.Data
<summary> Module with operations on HTML documents </summary>
--------------------
type HtmlDocument = private | HtmlDocument of docType: string * elements: HtmlNode list override ToString : unit -> string static member AsyncLoad : uri:string * ?encoding:Encoding -> Async<HtmlDocument> static member Load : stream:Stream -> HtmlDocument + 2 overloads static member New : docType:string * children:seq<HtmlNode> -> HtmlDocument + 1 overload static member Parse : text:string -> HtmlDocument
<summary> Represents an HTML document </summary>
module HtmlDocument from FSharp.Data
<summary> Module with operations on HTML documents </summary>
--------------------
type HtmlDocument = private | HtmlDocument of docType: string * elements: HtmlNode list override ToString : unit -> string static member AsyncLoad : uri:string * ?encoding:Encoding -> Async<HtmlDocument> static member Load : stream:Stream -> HtmlDocument + 2 overloads static member New : docType:string * children:seq<HtmlNode> -> HtmlDocument + 1 overload static member Parse : text:string -> HtmlDocument
<summary> Represents an HTML document </summary>
val makeFoolUrl : attrib:HtmlAttribute -> string
Match html node with "href" attribute and create transcript url
Match html node with "href" attribute and create transcript url
val attrib : HtmlAttribute
Multiple items
module HtmlAttribute from FSharp.Data
<summary> Module with operations on HTML attributes </summary>
--------------------
type HtmlAttribute = private | HtmlAttribute of name: string * value: string static member New : name:string * value:string -> HtmlAttribute
<summary>Represents an HTML attribute. The name is always normalized to lowercase</summary>
<namespacedoc><summary>Contains the primary types for the FSharp.Data package.</summary></namespacedoc>
module HtmlAttribute from FSharp.Data
<summary> Module with operations on HTML attributes </summary>
--------------------
type HtmlAttribute = private | HtmlAttribute of name: string * value: string static member New : name:string * value:string -> HtmlAttribute
<summary>Represents an HTML attribute. The name is always normalized to lowercase</summary>
<namespacedoc><summary>Contains the primary types for the FSharp.Data package.</summary></namespacedoc>
static member HtmlAttributeExtensions.Name : attr:HtmlAttribute -> string
static member HtmlAttributeExtensions.Value : attr:HtmlAttribute -> string
val stub : string
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T
<summary>Print to a string buffer and raise an exception with the given result. Helper printers must return strings.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
<summary>Print to a string buffer and raise an exception with the given result. Helper printers must return strings.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
val findTranscriptUrls : pageDoc:FrontPageDocument -> string []
Search for transcript urls
Search for transcript urls
val pageDoc : FrontPageDocument
Multiple items
val string : value:'T -> string
<summary>Converts the argument to a string using <c>ToString</c>.</summary>
<remarks>For standard integer and floating point values the and any type that implements <c>IFormattable</c><c>ToString</c> conversion uses <c>CultureInfo.InvariantCulture</c>. </remarks>
<param name="value">The input value.</param>
<returns>The converted string.</returns>
--------------------
type string = String
<summary>An abbreviation for the CLI type <see cref="T:System.String" />.</summary>
<category>Basic Types</category>
val string : value:'T -> string
<summary>Converts the argument to a string using <c>ToString</c>.</summary>
<remarks>For standard integer and floating point values the and any type that implements <c>IFormattable</c><c>ToString</c> conversion uses <c>CultureInfo.InvariantCulture</c>. </remarks>
<param name="value">The input value.</param>
<returns>The converted string.</returns>
--------------------
type string = String
<summary>An abbreviation for the CLI type <see cref="T:System.String" />.</summary>
<category>Basic Types</category>
static member CssSelectorExtensions.CssSelect : doc:HtmlDocument * selector:string -> HtmlNode list
module Seq
from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
val choose : chooser:('T -> 'U option) -> source:seq<'T> -> seq<'U>
<summary>Applies the given function to each element of the list. Return the list comprised of the results "x" for each element where the function returns Some(x).</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>
<param name="chooser">A function to transform items of type T into options of type U.</param>
<param name="source">The input sequence of type T.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<summary>Applies the given function to each element of the list. Return the list comprised of the results "x" for each element where the function returns Some(x).</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>
<param name="chooser">A function to transform items of type T into options of type U.</param>
<param name="source">The input sequence of type T.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
Multiple items
module HtmlNode from FSharp.Data
<summary> Module with operations on HTML nodes </summary>
--------------------
type HtmlNode = private | HtmlElement of name: string * attributes: HtmlAttribute list * elements: HtmlNode list | HtmlText of content: string | HtmlComment of content: string | HtmlCData of content: string override ToString : unit -> string static member NewCData : content:string -> HtmlNode static member NewComment : content:string -> HtmlNode static member NewElement : name:string -> HtmlNode + 3 overloads static member NewText : content:string -> HtmlNode static member Parse : text:string -> HtmlNode list static member ParseRooted : rootName:string * text:string -> HtmlNode
<summary> Represents an HTML node. The names of elements are always normalized to lowercase </summary>
module HtmlNode from FSharp.Data
<summary> Module with operations on HTML nodes </summary>
--------------------
type HtmlNode = private | HtmlElement of name: string * attributes: HtmlAttribute list * elements: HtmlNode list | HtmlText of content: string | HtmlComment of content: string | HtmlCData of content: string override ToString : unit -> string static member NewCData : content:string -> HtmlNode static member NewComment : content:string -> HtmlNode static member NewElement : name:string -> HtmlNode + 3 overloads static member NewText : content:string -> HtmlNode static member Parse : text:string -> HtmlNode list static member ParseRooted : rootName:string * text:string -> HtmlNode
<summary> Represents an HTML node. The names of elements are always normalized to lowercase </summary>
val tryGetAttribute : name:string -> n:HtmlNode -> HtmlAttribute option
<summary> Tries to return an attribute that exists on the current node </summary>
<param name="name">The name of the attribute to return.</param>
<param name="n">The given node</param>
<summary> Tries to return an attribute that exists on the current node </summary>
<param name="name">The name of the attribute to return.</param>
<param name="n">The given node</param>
val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The given function will be applied as elements are demanded using the <c>MoveNext</c> method on enumerators retrieved from the object.</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>
<param name="mapping">A function to transform items from the input sequence.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The given function will be applied as elements are demanded using the <c>MoveNext</c> method on enumerators retrieved from the object.</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently.</remarks>
<param name="mapping">A function to transform items from the input sequence.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
val toArray : source:seq<'T> -> 'T []
<summary>Builds an array from the given collection.</summary>
<param name="source">The input sequence.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<summary>Builds an array from the given collection.</summary>
<param name="source">The input sequence.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
val exampleFrontPageDoc : FrontPageDocument
static member HtmlDocument.Load : reader:IO.TextReader -> HtmlDocument
static member HtmlDocument.Load : stream:IO.Stream -> HtmlDocument
static member HtmlDocument.Load : uri:string * ?encoding:Text.Encoding -> HtmlDocument
static member HtmlDocument.Load : stream:IO.Stream -> HtmlDocument
static member HtmlDocument.Load : uri:string * ?encoding:Text.Encoding -> HtmlDocument
val exampleUrls : string []
type Array =
interface ICollection
interface IEnumerable
interface IList
interface IStructuralComparable
interface IStructuralEquatable
interface ICloneable
new : unit -> unit
member Clone : unit -> obj
member CopyTo : array: Array * index: int -> unit + 1 overload
member GetEnumerator : unit -> IEnumerator
...
<summary>Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.</summary>
<summary>Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.</summary>
val take : count:int -> array:'T [] -> 'T []
<summary>Returns the first N elements of the array.</summary>
<remarks>Throws <c>InvalidOperationException</c> if the count exceeds the number of elements in the array. <c>Array.truncate</c> returns as many items as the array contains instead of throwing an exception.</remarks>
<param name="count">The number of items to take.</param>
<param name="array">The input array.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<exception cref="T:System.ArgumentException">Thrown when the input array is empty.</exception>
<exception cref="T:System.InvalidOperationException">Thrown when count exceeds the number of elements in the list.</exception>
<summary>Returns the first N elements of the array.</summary>
<remarks>Throws <c>InvalidOperationException</c> if the count exceeds the number of elements in the array. <c>Array.truncate</c> returns as many items as the array contains instead of throwing an exception.</remarks>
<param name="count">The number of items to take.</param>
<param name="array">The input array.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<exception cref="T:System.ArgumentException">Thrown when the input array is empty.</exception>
<exception cref="T:System.InvalidOperationException">Thrown when count exceeds the number of elements in the list.</exception>
val iter : action:('T -> unit) -> array:'T [] -> unit
<summary>Applies the given function to each element of the array.</summary>
<param name="action">The function to apply.</param>
<param name="array">The input array.</param>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<summary>Applies the given function to each element of the array.</summary>
<param name="action">The function to apply.</param>
<param name="array">The input array.</param>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
val xs : string
val printfn : format:Printf.TextWriterFormat<'T> -> 'T
<summary>Print to <c>stdout</c> using the given format, and add a newline.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
<summary>Print to <c>stdout</c> using the given format, and add a newline.</summary>
<param name="format">The formatter.</param>
<returns>The formatted result.</returns>
type TranscriptDocument = HtmlDocument
First three urls
First three urls
val teslaDoc : TranscriptDocument
Tesla transcript html document
Tesla transcript html document
Multiple items
module List from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.list`1" />.</summary>
<namespacedoc><summary>Operations for collections such as lists, arrays, sets, maps and sequences. See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/fsharp-collection-types">F# Collection Types</a> in the F# Language Guide. </summary></namespacedoc>
--------------------
type List<'T> = | ( [] ) | ( :: ) of Head: 'T * Tail: 'T list interface IReadOnlyList<'T> interface IReadOnlyCollection<'T> interface IEnumerable interface IEnumerable<'T> member GetReverseIndex : rank:int * offset:int -> int member GetSlice : startIndex:int option * endIndex:int option -> 'T list static member Cons : head:'T * tail:'T list -> 'T list member Head : 'T member IsEmpty : bool member Item : index:int -> 'T with get ...
<summary>The type of immutable singly-linked lists.</summary>
<remarks>Use the constructors <c>[]</c> and <c>::</c> (infix) to create values of this type, or the notation <c>[1;2;3]</c>. Use the values in the <c>List</c> module to manipulate values of this type, or pattern match against the values directly. </remarks>
<exclude />
module List from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.list`1" />.</summary>
<namespacedoc><summary>Operations for collections such as lists, arrays, sets, maps and sequences. See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/fsharp-collection-types">F# Collection Types</a> in the F# Language Guide. </summary></namespacedoc>
--------------------
type List<'T> = | ( [] ) | ( :: ) of Head: 'T * Tail: 'T list interface IReadOnlyList<'T> interface IReadOnlyCollection<'T> interface IEnumerable interface IEnumerable<'T> member GetReverseIndex : rank:int * offset:int -> int member GetSlice : startIndex:int option * endIndex:int option -> 'T list static member Cons : head:'T * tail:'T list -> 'T list member Head : 'T member IsEmpty : bool member Item : index:int -> 'T with get ...
<summary>The type of immutable singly-linked lists.</summary>
<remarks>Use the constructors <c>[]</c> and <c>::</c> (infix) to create values of this type, or the notation <c>[1;2;3]</c>. Use the values in the <c>List</c> module to manipulate values of this type, or pattern match against the values directly. </remarks>
<exclude />
val map : mapping:('T -> 'U) -> list:'T list -> 'U list
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection.</summary>
<param name="mapping">The function to transform elements from the input list.</param>
<param name="list">The input list.</param>
<returns>The list of transformed elements.</returns>
<summary>Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection.</summary>
<param name="mapping">The function to transform elements from the input list.</param>
<param name="list">The input list.</param>
<returns>The list of transformed elements.</returns>
val x : HtmlNode
static member HtmlNodeExtensions.InnerText : n:HtmlNode -> string
val distinct : list:'T list -> 'T list (requires equality)
<summary>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.</summary>
<param name="list">The input list.</param>
<returns>The result list.</returns>
<summary>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.</summary>
<param name="list">The input list.</param>
<returns>The result list.</returns>
val tryExactlyOne : list:'T list -> 'T option
<summary>Returns the only element of the list or <c>None</c> if it is empty or contains more than one element.</summary>
<param name="list">The input list.</param>
<returns>The only element of the list or None.</returns>
<summary>Returns the only element of the list or <c>None</c> if it is empty or contains more than one element.</summary>
<param name="list">The input list.</param>
<returns>The only element of the list or None.</returns>
val cleanTickerExchangeText : doc:TranscriptDocument -> string option
val doc : TranscriptDocument
val distinct : source:seq<'T> -> seq<'T> (requires equality)
<summary>Returns a sequence that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the sequence then the later occurrences are discarded.</summary>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<summary>Returns a sequence that contains no duplicate entries according to generic hash and equality comparisons on the entries. If an element occurs multiple times in the sequence then the later occurrences are discarded.</summary>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
val tryExactlyOne : source:seq<'T> -> 'T option
<summary>Returns the only element of the sequence or <c>None</c> if sequence is empty or contains more than one element.</summary>
<param name="source">The input sequence.</param>
<returns>The only element of the sequence or None.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<summary>Returns the only element of the sequence or <c>None</c> if sequence is empty or contains more than one element.</summary>
<param name="source">The input sequence.</param>
<returns>The only element of the sequence or None.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
val tryTickerExchange : tickerInfo:string -> (string * string) option
Match inner text from html node to a ticker and exchange
Match inner text from html node to a ticker and exchange
val tickerInfo : string
type 'T option = Option<'T>
<summary>The type of optional values. When used from other CLI languages the empty option is the <c>null</c> value. </summary>
<remarks>Use the constructors <c>Some</c> and <c>None</c> to create values of this type. Use the values in the <c>Option</c> module to manipulate values of this type, or pattern match against the values directly. 'None' values will appear as the value <c>null</c> to other CLI languages. Instance methods on this type will appear as static methods to other CLI languages due to the use of <c>null</c> as a value representation.</remarks>
<category index="3">Options</category>
<summary>The type of optional values. When used from other CLI languages the empty option is the <c>null</c> value. </summary>
<remarks>Use the constructors <c>Some</c> and <c>None</c> to create values of this type. Use the values in the <c>Option</c> module to manipulate values of this type, or pattern match against the values directly. 'None' values will appear as the value <c>null</c> to other CLI languages. Instance methods on this type will appear as static methods to other CLI languages due to the use of <c>null</c> as a value representation.</remarks>
<category index="3">Options</category>
String.Split([<ParamArray>] separator: char []) : string []
String.Split(separator: string [], options: StringSplitOptions) : string []
String.Split(separator: string,?options: StringSplitOptions) : string []
String.Split(separator: char [], options: StringSplitOptions) : string []
String.Split(separator: char [], count: int) : string []
String.Split(separator: char,?options: StringSplitOptions) : string []
String.Split(separator: string [], count: int, options: StringSplitOptions) : string []
String.Split(separator: string, count: int,?options: StringSplitOptions) : string []
String.Split(separator: char [], count: int, options: StringSplitOptions) : string []
String.Split(separator: char, count: int,?options: StringSplitOptions) : string []
String.Split(separator: string [], options: StringSplitOptions) : string []
String.Split(separator: string,?options: StringSplitOptions) : string []
String.Split(separator: char [], options: StringSplitOptions) : string []
String.Split(separator: char [], count: int) : string []
String.Split(separator: char,?options: StringSplitOptions) : string []
String.Split(separator: string [], count: int, options: StringSplitOptions) : string []
String.Split(separator: string, count: int,?options: StringSplitOptions) : string []
String.Split(separator: char [], count: int, options: StringSplitOptions) : string []
String.Split(separator: char, count: int,?options: StringSplitOptions) : string []
val exchange : string
val ticker : string
union case Option.Some: Value: 'T -> Option<'T>
<summary>The representation of "Value of type 'T"</summary>
<param name="Value">The input value.</param>
<returns>An option representing the value.</returns>
<summary>The representation of "Value of type 'T"</summary>
<param name="Value">The input value.</param>
<returns>An option representing the value.</returns>
union case Option.None: Option<'T>
<summary>The representation of "No value"</summary>
<summary>The representation of "No value"</summary>
val findTickerExchange : doc:TranscriptDocument -> (string * string) option
Search for ticker and exchange
Search for ticker and exchange
module Option
from Microsoft.FSharp.Core
<summary>Contains operations for working with options.</summary>
<category>Options</category>
<summary>Contains operations for working with options.</summary>
<category>Options</category>
val bind : binder:('T -> 'U option) -> option:'T option -> 'U option
<summary><c>bind f inp</c> evaluates to <c>match inp with None -> None | Some x -> f x</c></summary>
<param name="binder">A function that takes the value of type T from an option and transforms it into an option containing a value of type U.</param>
<param name="option">The input option.</param>
<example><code> let tryParse input = match System.Int32.TryParse input with | true, v -> Some v | false, _ -> None None |> Option.bind tryParse // evaluates to None Some "42" |> Option.bind tryParse // evaluates to Some 42 Some "Forty-two" |> Option.bind tryParse // evaluates to None </code></example>
<returns>An option of the output type of the binder.</returns>
<summary><c>bind f inp</c> evaluates to <c>match inp with None -> None | Some x -> f x</c></summary>
<param name="binder">A function that takes the value of type T from an option and transforms it into an option containing a value of type U.</param>
<param name="option">The input option.</param>
<example><code> let tryParse input = match System.Int32.TryParse input with | true, v -> Some v | false, _ -> None None |> Option.bind tryParse // evaluates to None Some "42" |> Option.bind tryParse // evaluates to Some 42 Some "Forty-two" |> Option.bind tryParse // evaluates to None </code></example>
<returns>An option of the output type of the binder.</returns>
val cleanDate : node:HtmlNode -> string option
Format date string
Format date string
val node : HtmlNode
val dateArr : string []
val month : string
val day : string
val year : string
val findDate : doc:TranscriptDocument -> string option
Search for transcript date
Search for transcript date
val cleanTime : node:HtmlNode -> string
Date of Tesla's call:
Format time string
Date of Tesla's call:
Format time string
val txt : string
String.Contains(value: string) : bool
String.Contains(value: char) : bool
String.Contains(value: string, comparisonType: StringComparison) : bool
String.Contains(value: char, comparisonType: StringComparison) : bool
String.Contains(value: char) : bool
String.Contains(value: string, comparisonType: StringComparison) : bool
String.Contains(value: char, comparisonType: StringComparison) : bool
String.Replace(oldValue: string, newValue: string) : string
String.Replace(oldChar: char, newChar: char) : string
String.Replace(oldValue: string, newValue: string, comparisonType: StringComparison) : string
String.Replace(oldValue: string, newValue: string, ignoreCase: bool, culture: Globalization.CultureInfo) : string
String.Replace(oldChar: char, newChar: char) : string
String.Replace(oldValue: string, newValue: string, comparisonType: StringComparison) : string
String.Replace(oldValue: string, newValue: string, ignoreCase: bool, culture: Globalization.CultureInfo) : string
val findTime : doc:TranscriptDocument -> string option
Search for transcript time
Search for transcript time
val map : mapping:('T -> 'U) -> option:'T option -> 'U option
<summary><c>map f inp</c> evaluates to <c>match inp with None -> None | Some x -> Some (f x)</c>.</summary>
<param name="mapping">A function to apply to the option value.</param>
<param name="option">The input option.</param>
<example><code> None |> Option.map (fun x -> x * 2) // evaluates to None Some 42 |> Option.map (fun x -> x * 2) // evaluates to Some 84 </code></example>
<returns>An option of the input value after applying the mapping function, or None if the input is None.</returns>
<summary><c>map f inp</c> evaluates to <c>match inp with None -> None | Some x -> Some (f x)</c>.</summary>
<param name="mapping">A function to apply to the option value.</param>
<param name="option">The input option.</param>
<example><code> None |> Option.map (fun x -> x * 2) // evaluates to None Some 42 |> Option.map (fun x -> x * 2) // evaluates to Some 84 </code></example>
<returns>An option of the input value after applying the mapping function, or None if the input is None.</returns>
val convertToDateTime : date:string * time:string -> DateTime
Time of Tesla's call
DateTime converter
Time of Tesla's call
DateTime converter
val date : string
val time : string
Multiple items
[<Struct>] type DateTime = new : year: int * month: int * day: int -> unit + 10 overloads member Add : value: TimeSpan -> DateTime member AddDays : value: float -> DateTime member AddHours : value: float -> DateTime member AddMilliseconds : value: float -> DateTime member AddMinutes : value: float -> DateTime member AddMonths : months: int -> DateTime member AddSeconds : value: float -> DateTime member AddTicks : value: int64 -> DateTime member AddYears : value: int -> DateTime ...
<summary>Represents an instant in time, typically expressed as a date and time of day.</summary>
--------------------
DateTime ()
(+0 other overloads)
DateTime(ticks: int64) : DateTime
(+0 other overloads)
DateTime(ticks: int64, kind: DateTimeKind) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, kind: DateTimeKind) : DateTime
(+0 other overloads)
[<Struct>] type DateTime = new : year: int * month: int * day: int -> unit + 10 overloads member Add : value: TimeSpan -> DateTime member AddDays : value: float -> DateTime member AddHours : value: float -> DateTime member AddMilliseconds : value: float -> DateTime member AddMinutes : value: float -> DateTime member AddMonths : months: int -> DateTime member AddSeconds : value: float -> DateTime member AddTicks : value: int64 -> DateTime member AddYears : value: int -> DateTime ...
<summary>Represents an instant in time, typically expressed as a date and time of day.</summary>
--------------------
DateTime ()
(+0 other overloads)
DateTime(ticks: int64) : DateTime
(+0 other overloads)
DateTime(ticks: int64, kind: DateTimeKind) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int) : DateTime
(+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, kind: DateTimeKind) : DateTime
(+0 other overloads)
val dateExpr : string
val dateFormat : string
DateTime.ParseExact(s: string, format: string, provider: IFormatProvider) : DateTime
DateTime.ParseExact(s: string, formats: string [], provider: IFormatProvider, style: Globalization.DateTimeStyles) : DateTime
DateTime.ParseExact(s: string, format: string, provider: IFormatProvider, style: Globalization.DateTimeStyles) : DateTime
DateTime.ParseExact(s: ReadOnlySpan<char>, formats: string [], provider: IFormatProvider,?style: Globalization.DateTimeStyles) : DateTime
DateTime.ParseExact(s: ReadOnlySpan<char>, format: ReadOnlySpan<char>, provider: IFormatProvider,?style: Globalization.DateTimeStyles) : DateTime
DateTime.ParseExact(s: string, formats: string [], provider: IFormatProvider, style: Globalization.DateTimeStyles) : DateTime
DateTime.ParseExact(s: string, format: string, provider: IFormatProvider, style: Globalization.DateTimeStyles) : DateTime
DateTime.ParseExact(s: ReadOnlySpan<char>, formats: string [], provider: IFormatProvider,?style: Globalization.DateTimeStyles) : DateTime
DateTime.ParseExact(s: ReadOnlySpan<char>, format: ReadOnlySpan<char>, provider: IFormatProvider,?style: Globalization.DateTimeStyles) : DateTime
namespace System.Globalization
Multiple items
type CultureInfo = interface ICloneable interface IFormatProvider new : culture: int -> unit + 3 overloads member ClearCachedData : unit -> unit member Clone : unit -> obj member Equals : value: obj -> bool member GetConsoleFallbackUICulture : unit -> CultureInfo member GetFormat : formatType: Type -> obj member GetHashCode : unit -> int member ToString : unit -> string ...
<summary>Provides information about a specific culture (called a locale for unmanaged code development). The information includes the names for the culture, the writing system, the calendar used, the sort order of strings, and formatting for dates and numbers.</summary>
--------------------
Globalization.CultureInfo(culture: int) : Globalization.CultureInfo
Globalization.CultureInfo(name: string) : Globalization.CultureInfo
Globalization.CultureInfo(culture: int, useUserOverride: bool) : Globalization.CultureInfo
Globalization.CultureInfo(name: string, useUserOverride: bool) : Globalization.CultureInfo
type CultureInfo = interface ICloneable interface IFormatProvider new : culture: int -> unit + 3 overloads member ClearCachedData : unit -> unit member Clone : unit -> obj member Equals : value: obj -> bool member GetConsoleFallbackUICulture : unit -> CultureInfo member GetFormat : formatType: Type -> obj member GetHashCode : unit -> int member ToString : unit -> string ...
<summary>Provides information about a specific culture (called a locale for unmanaged code development). The information includes the names for the culture, the writing system, the calendar used, the sort order of strings, and formatting for dates and numbers.</summary>
--------------------
Globalization.CultureInfo(culture: int) : Globalization.CultureInfo
Globalization.CultureInfo(name: string) : Globalization.CultureInfo
Globalization.CultureInfo(culture: int, useUserOverride: bool) : Globalization.CultureInfo
Globalization.CultureInfo(name: string, useUserOverride: bool) : Globalization.CultureInfo
property Globalization.CultureInfo.InvariantCulture: Globalization.CultureInfo with get
<summary>Gets the <see cref="T:System.Globalization.CultureInfo" /> object that is culture-independent (invariant).</summary>
<returns>The object that is culture-independent (invariant).</returns>
<summary>Gets the <see cref="T:System.Globalization.CultureInfo" /> object that is culture-independent (invariant).</summary>
<returns>The object that is culture-independent (invariant).</returns>
val findDateTime : doc:TranscriptDocument -> DateTime option
Search for and match date and time
Search for and match date and time
val dt : DateTime
val findParagraphs : doc:TranscriptDocument -> string []
Tesla call DateTime
Tesla call DateTime
val filter : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
<summary>Returns a new collection containing only the elements of the collection for which the given predicate returns "true". This is a synonym for Seq.where.</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Remember sequence is lazy, effects are delayed until it is enumerated.</remarks>
<param name="predicate">A function to test whether each item in the input sequence should be included in the output.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<summary>Returns a new collection containing only the elements of the collection for which the given predicate returns "true". This is a synonym for Seq.where.</summary>
<remarks>The returned sequence may be passed between threads safely. However, individual IEnumerator values generated from the returned sequence should not be accessed concurrently. Remember sequence is lazy, effects are delayed until it is enumerated.</remarks>
<param name="predicate">A function to test whether each item in the input sequence should be included in the output.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
val x : string
val skip : count:int -> source:seq<'T> -> seq<'T>
<summary>Returns a sequence that skips N elements of the underlying sequence and then yields the remaining elements of the sequence.</summary>
<param name="count">The number of items to skip.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<exception cref="T:System.InvalidOperationException">Thrown when count exceeds the number of elements in the sequence.</exception>
<summary>Returns a sequence that skips N elements of the underlying sequence and then yields the remaining elements of the sequence.</summary>
<param name="count">The number of items to skip.</param>
<param name="source">The input sequence.</param>
<returns>The result sequence.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
<exception cref="T:System.InvalidOperationException">Thrown when count exceeds the number of elements in the sequence.</exception>
val firstCharacters : paragraph:string -> string
val paragraph : string
property String.Length: int with get
val map : mapping:('T -> 'U) -> array:'T [] -> 'U []
<summary>Builds a new array whose elements are the results of applying the given function to each of the elements of the array.</summary>
<param name="mapping">The function to transform elements of the array.</param>
<param name="array">The input array.</param>
<returns>The array of transformed elements.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<summary>Builds a new array whose elements are the results of applying the given function to each of the elements of the array.</summary>
<param name="mapping">The function to transform elements of the array.</param>
<param name="array">The input array.</param>
<returns>The array of transformed elements.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
val iteri : action:(int -> 'T -> unit) -> array:'T [] -> unit
<summary>Applies the given function to each element of the array. The integer passed to the function indicates the index of element.</summary>
<param name="action">The function to apply to each index and element.</param>
<param name="array">The input array.</param>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<summary>Applies the given function to each element of the array. The integer passed to the function indicates the index of element.</summary>
<param name="action">The function to apply to each index and element.</param>
<param name="array">The input array.</param>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
namespace System.Text
namespace System.Text.RegularExpressions
val quarterRegex : Regex
Regular Expression
Regular Expression
Multiple items
type Regex = interface ISerializable new : unit -> unit + 4 overloads member GetGroupNames : unit -> string [] member GetGroupNumbers : unit -> int [] member GroupNameFromNumber : i: int -> string member GroupNumberFromName : name: string -> int member InitializeReferences : unit -> unit member IsMatch : input: string -> bool + 4 overloads member Match : input: string -> Match + 5 overloads member Matches : input: string -> MatchCollection + 4 overloads ...
<summary>Represents an immutable regular expression.</summary>
--------------------
Regex(pattern: string) : Regex
Regex(pattern: string, options: RegexOptions) : Regex
Regex(pattern: string, options: RegexOptions, matchTimeout: TimeSpan) : Regex
type Regex = interface ISerializable new : unit -> unit + 4 overloads member GetGroupNames : unit -> string [] member GetGroupNumbers : unit -> int [] member GroupNameFromNumber : i: int -> string member GroupNumberFromName : name: string -> int member InitializeReferences : unit -> unit member IsMatch : input: string -> bool + 4 overloads member Match : input: string -> Match + 5 overloads member Matches : input: string -> MatchCollection + 4 overloads ...
<summary>Represents an immutable regular expression.</summary>
--------------------
Regex(pattern: string) : Regex
Regex(pattern: string, options: RegexOptions) : Regex
Regex(pattern: string, options: RegexOptions, matchTimeout: TimeSpan) : Regex
val getQNumb : q:string -> int option
Extract number from "Q\d{1}"
Extract number from "Q\d{1}"
val q : string
Multiple items
val int : value:'T -> int (requires member op_Explicit)
<summary>Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using <c>Int32.Parse()</c> with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted int</returns>
--------------------
[<Struct>] type int = int32
<summary>An abbreviation for the CLI type <see cref="T:System.Int32" />.</summary>
<category>Basic Types</category>
--------------------
type int<'Measure> = int
<summary>The type of 32-bit signed integer numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to <see cref="T:System.Int32" />.</summary>
<category>Basic Types with Units of Measure</category>
val int : value:'T -> int (requires member op_Explicit)
<summary>Converts the argument to signed 32-bit integer. This is a direct conversion for all primitive numeric types. For strings, the input is converted using <c>Int32.Parse()</c> with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type.</summary>
<param name="value">The input value.</param>
<returns>The converted int</returns>
--------------------
[<Struct>] type int = int32
<summary>An abbreviation for the CLI type <see cref="T:System.Int32" />.</summary>
<category>Basic Types</category>
--------------------
type int<'Measure> = int
<summary>The type of 32-bit signed integer numbers, annotated with a unit of measure. The unit of measure is erased in compiled code and when values of this type are analyzed using reflection. The type is representationally equivalent to <see cref="T:System.Int32" />.</summary>
<category>Basic Types with Units of Measure</category>
val xs : char []
val q : char
val qNumb : char
[<Struct>]
type Char =
member CompareTo : value: char -> int + 1 overload
member Equals : obj: char -> bool + 1 overload
member GetHashCode : unit -> int
member GetTypeCode : unit -> TypeCode
member System.IConvertible.ToBoolean : provider: IFormatProvider -> bool
member System.IConvertible.ToByte : provider: IFormatProvider -> byte
member System.IConvertible.ToChar : provider: IFormatProvider -> char
member System.IConvertible.ToDateTime : provider: IFormatProvider -> DateTime
member System.IConvertible.ToDecimal : provider: IFormatProvider -> decimal
member System.IConvertible.ToDouble : provider: IFormatProvider -> float
...
<summary>Represents a character as a UTF-16 code unit.</summary>
<summary>Represents a character as a UTF-16 code unit.</summary>
Char.GetNumericValue(c: char) : float
Char.GetNumericValue(s: string, index: int) : float
Char.GetNumericValue(s: string, index: int) : float
val findFiscalQuarter : doc:TranscriptDocument -> int option
val xs : HtmlNode
Regex.Match(input: string) : Match
Regex.Match(input: string, startat: int) : Match
Regex.Match(input: string, beginning: int, length: int) : Match
Regex.Match(input: string, startat: int) : Match
Regex.Match(input: string, beginning: int, length: int) : Match
val xs : Match
property Capture.Value: string with get
<summary>Gets the captured substring from the input string.</summary>
<returns>The substring that is captured by the match.</returns>
<summary>Gets the captured substring from the input string.</summary>
<returns>The substring that is captured by the match.</returns>
type CallId =
{ Ticker: string
Exchange: string
Date: DateTime
FiscalQuarter: int }
CallId.Ticker: string
CallId.Exchange: string
CallId.Date: DateTime
CallId.FiscalQuarter: int
type EarningsCall =
{ CallId: CallId
Transcript: string [] }
Multiple items
EarningsCall.CallId: CallId
--------------------
type CallId = { Ticker: string Exchange: string Date: DateTime FiscalQuarter: int }
EarningsCall.CallId: CallId
--------------------
type CallId = { Ticker: string Exchange: string Date: DateTime FiscalQuarter: int }
EarningsCall.Transcript: string []
val parseTrancriptDoc : doc:TranscriptDocument -> EarningsCall option
Search for ticker, exchange, date and paragraphs
Search for ticker, exchange, date and paragraphs
val matchExpr : (string * string) option * DateTime option * int option
val date : DateTime
val fiscalQuarter : int
val callId : CallId
val teslaTranscript : EarningsCall option
Tesla transcript record
Tesla transcript record
val iter : action:('T -> unit) -> option:'T option -> unit
<summary><c>iter f inp</c> executes <c>match inp with None -> () | Some x -> f x</c>.</summary>
<param name="action">A function to apply to the option value.</param>
<param name="option">The input option.</param>
<example><code> None |> Option.iter (printfn "%s") // does nothing Some "Hello world" |> Option.iter (printfn "%s") // prints "Hello world" </code></example>
<returns>Unit if the option is None, otherwise it returns the result of applying the predicate to the option value.</returns>
<summary><c>iter f inp</c> executes <c>match inp with None -> () | Some x -> f x</c>.</summary>
<param name="action">A function to apply to the option value.</param>
<param name="option">The input option.</param>
<example><code> None |> Option.iter (printfn "%s") // does nothing Some "Hello world" |> Option.iter (printfn "%s") // prints "Hello world" </code></example>
<returns>Unit if the option is None, otherwise it returns the result of applying the predicate to the option value.</returns>
val xs : EarningsCall
EarningsCall.CallId: CallId
val truncate : count:int -> array:'T [] -> 'T []
<summary>Returns at most N elements in a new array.</summary>
<param name="count">The maximum number of items to return.</param>
<param name="array">The input array.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<summary>Returns at most N elements in a new array.</summary>
<param name="count">The maximum number of items to return.</param>
<param name="array">The input array.</param>
<returns>The result array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
val exampleTranscripts : EarningsCall []
Parsing transcripts from front page
Parsing transcripts from front page
val choose : chooser:('T -> 'U option) -> array:'T [] -> 'U []
<summary>Applies the given function to each element of the array. Returns the array comprised of the results "x" for each element where the function returns Some(x)</summary>
<param name="chooser">The function to generate options from the elements.</param>
<param name="array">The input array.</param>
<returns>The array of results.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<summary>Applies the given function to each element of the array. Returns the array comprised of the results "x" for each element where the function returns Some(x)</summary>
<param name="chooser">The function to generate options from the elements.</param>
<param name="array">The input array.</param>
<returns>The array of results.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
val tUrl : string
val doc : HtmlDocument
property Array.Length: int with get
<summary>Gets the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary>
<exception cref="T:System.OverflowException">The array is multidimensional and contains more than <see cref="F:System.Int32.MaxValue" /> elements.</exception>
<returns>The total number of elements in all the dimensions of the <see cref="T:System.Array" />; zero if there are no elements in the array.</returns>
<summary>Gets the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary>
<exception cref="T:System.OverflowException">The array is multidimensional and contains more than <see cref="F:System.Int32.MaxValue" /> elements.</exception>
<returns>The total number of elements in all the dimensions of the <see cref="T:System.Array" />; zero if there are no elements in the array.</returns>
val tId : CallId
Total number of transcripts
First 5 transcripts
Total number of transcripts
First 5 transcripts
namespace Plotly
namespace Plotly.NET
val transcriptTimesHistogram : GenericChart.GenericChart
Histogram
Histogram
val callTimes : string []
property DateTime.TimeOfDay: TimeSpan with get
<summary>Gets the time of day for this instance.</summary>
<returns>A time interval that represents the fraction of the day that has elapsed since midnight.</returns>
<summary>Gets the time of day for this instance.</summary>
<returns>A time interval that represents the fraction of the day that has elapsed since midnight.</returns>
TimeSpan.ToString() : string
TimeSpan.ToString(format: string) : string
TimeSpan.ToString(format: string, formatProvider: IFormatProvider) : string
TimeSpan.ToString(format: string) : string
TimeSpan.ToString(format: string, formatProvider: IFormatProvider) : string
val sort : array:'T [] -> 'T [] (requires comparison)
<summary>Sorts the elements of an array, returning a new array. Elements are compared using <see cref="M:Microsoft.FSharp.Core.Operators.compare" />. </summary>
<remarks>This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using <see cref="M:Microsoft.FSharp.Collections.SeqModule.Sort" />.</remarks>
<param name="array">The input array.</param>
<returns>The sorted array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<summary>Sorts the elements of an array, returning a new array. Elements are compared using <see cref="M:Microsoft.FSharp.Core.Operators.compare" />. </summary>
<remarks>This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. For a stable sort, consider using <see cref="M:Microsoft.FSharp.Collections.SeqModule.Sort" />.</remarks>
<param name="array">The input array.</param>
<returns>The sorted array.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
type Chart =
static member Area : x:seq<#IConvertible> * y:seq<#IConvertible> * ?Name:string * ?ShowMarkers:bool * ?Showlegend:bool * ?MarkerSymbol:Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<#IConvertible> * ?TextPosition:TextPosition * ?TextFont:Font * ?Dash:DrawingStyle * ?Width:float -> GenericChart + 1 overload
static member Bar : keys:seq<#IConvertible> * values:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?Color:string * ?Opacity:float * ?Labels:seq<#IConvertible> * ?TextPosition:TextPosition * ?TextFont:Font * ?Marker:Marker -> GenericChart + 1 overload
static member BoxPlot : ?x:'a0 * ?y:'a1 * ?Name:string * ?Showlegend:bool * ?Color:string * ?Fillcolor:'a2 * ?Opacity:float * ?Whiskerwidth:'a3 * ?Boxpoints:Boxpoints * ?Boxmean:BoxMean * ?Jitter:'a4 * ?Pointpos:'a5 * ?Orientation:Orientation * ?Marker:Marker * ?Line:Line * ?Alignmentgroup:'a6 * ?Offsetgroup:'a7 * ?Notched:bool * ?NotchWidth:float * ?QuartileMethod:QuartileMethod -> GenericChart + 1 overload
static member Bubble : x:seq<#IConvertible> * y:seq<#IConvertible> * sizes:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?MarkerSymbol:Symbol * ?Color:string * ?Opacity:float * ?Labels:seq<#IConvertible> * ?TextPosition:TextPosition * ?TextFont:Font * ?StackGroup:string * ?Orientation:Orientation * ?GroupNorm:GroupNorm * ?UseWebGL:bool -> GenericChart + 1 overload
static member Candlestick : open:seq<#IConvertible> * high:seq<#IConvertible> * low:seq<#IConvertible> * close:seq<#IConvertible> * x:seq<#IConvertible> * ?Increasing:Line * ?Decreasing:Line * ?WhiskerWidth:float * ?Line:Line * ?XCalendar:Calendar -> GenericChart + 1 overload
static member ChoroplethMap : locations:seq<string> * z:seq<#IConvertible> * ?Text:seq<#IConvertible> * ?Locationmode:LocationFormat * ?Autocolorscale:bool * ?Colorscale:Colorscale * ?Colorbar:Colorbar * ?Marker:Marker * ?GeoJson:'a2 * ?FeatureIdKey:string * ?Zmin:float * ?Zmax:float -> GenericChart
static member ChoroplethMapbox : locations:seq<#IConvertible> * z:seq<#IConvertible> * geoJson:'a2 * ?FeatureIdKey:string * ?Text:seq<#IConvertible> * ?Below:string * ?Colorscale:Colorscale * ?Colorbar:Colorbar * ?ZAuto:bool * ?ZMin:float * ?ZMid:float * ?ZMax:float -> GenericChart
static member Column : keys:seq<#IConvertible> * values:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?Color:string * ?Opacity:float * ?Labels:seq<#IConvertible> * ?TextPosition:TextPosition * ?TextFont:Font * ?Marker:Marker -> GenericChart + 1 overload
static member Contour : data:seq<#seq<'a1>> * ?X:seq<#IConvertible> * ?Y:seq<#IConvertible> * ?Name:string * ?Showlegend:bool * ?Opacity:float * ?Colorscale:Colorscale * ?Showscale:'a4 * ?zSmooth:SmoothAlg * ?Colorbar:'a5 -> GenericChart (requires 'a1 :> IConvertible)
static member DensityMapbox : lon:seq<#IConvertible> * lat:seq<#IConvertible> * ?Z:seq<#IConvertible> * ?Radius:float * ?Opacity:float * ?Text:seq<#IConvertible> * ?Below:string * ?Colorscale:Colorscale * ?Colorbar:Colorbar * ?Showscale:bool * ?ZAuto:bool * ?ZMin:float * ?ZMid:float * ?ZMax:float -> GenericChart + 1 overload
...
<summary> Provides a set of static methods for creating charts. </summary>
<summary> Provides a set of static methods for creating charts. </summary>
static member Chart.Histogram : data:seq<#IConvertible> * ?Orientation:StyleParam.Orientation * ?Name:string * ?Showlegend:bool * ?Opacity:float * ?Color:string * ?HistNorm:StyleParam.HistNorm * ?HistFunc:StyleParam.HistNorm * ?nBinsx:int * ?nBinsy:int * ?Xbins:Bins * ?Ybins:Bins * ?xError:'b * ?yError:'c -> GenericChart.GenericChart
static member Chart.withTitle : title:string * ?Titlefont:Font -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.withY_AxisStyle : title:string * ?MinMax:(float * float) * ?Showgrid:bool * ?Showline:bool * ?Side:StyleParam.Side * ?Overlaying:StyleParam.AxisAnchorId * ?Id:int * ?Domain:(float * float) * ?Position:float * ?Zeroline:bool * ?Anchor:StyleParam.AxisAnchorId -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.withSize : width:float * height:float -> (GenericChart.GenericChart -> GenericChart.GenericChart)
static member Chart.Show : ch:GenericChart.GenericChart -> unit
module GenericChart
from Plotly.NET
<summary> Module to represent a GenericChart </summary>
<summary> Module to represent a GenericChart </summary>
val toChartHTML : gChart:GenericChart.GenericChart -> string
<summary> Converts a GenericChart to it HTML representation. The div layer has a default size of 600 if not specified otherwise. </summary>
<summary> Converts a GenericChart to it HTML representation. The div layer has a default size of 600 if not specified otherwise. </summary>
val asyncTranscript : url:string -> Async<EarningsCall option>
val url : string
val loop : (int -> string -> Async<EarningsCall option>)
val attempt : int
val async : AsyncBuilder
<summary>Builds an asynchronous workflow using computation expression syntax.</summary>
<summary>Builds an asynchronous workflow using computation expression syntax.</summary>
val transcriptDoc : HtmlDocument
static member HtmlDocument.AsyncLoad : uri:string * ?encoding:Text.Encoding -> Async<HtmlDocument>
val transcriptRec : EarningsCall option
val e : exn
Multiple items
type Async = static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool> static member AwaitTask : task:Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool> static member CancelDefaultToken : unit -> unit static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>> static member Choice : computations:seq<Async<'T option>> -> Async<'T option> static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...
<summary>Holds static members for creating and manipulating asynchronous computations.</summary>
<remarks> See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<category index="1">Async Programming</category>
--------------------
type Async<'T> =
<summary> An asynchronous computation, which, when run, will eventually produce a value of type T, or else raises an exception. </summary>
<remarks> This type has no members. Asynchronous computations are normally specified either by using an async expression or the static methods in the <see cref="T:Microsoft.FSharp.Control.Async" /> type. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<namespacedoc><summary> Library functionality for asynchronous programming, events and agents. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">Asynchronous Programming</a>, <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/members/events">Events</a> and <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/lazy-expressions">Lazy Expressions</a> in the F# Language Guide. </summary></namespacedoc>
<category index="1">Async Programming</category>
type Async = static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool> static member AwaitTask : task:Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool> static member CancelDefaultToken : unit -> unit static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>> static member Choice : computations:seq<Async<'T option>> -> Async<'T option> static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...
<summary>Holds static members for creating and manipulating asynchronous computations.</summary>
<remarks> See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<category index="1">Async Programming</category>
--------------------
type Async<'T> =
<summary> An asynchronous computation, which, when run, will eventually produce a value of type T, or else raises an exception. </summary>
<remarks> This type has no members. Asynchronous computations are normally specified either by using an async expression or the static methods in the <see cref="T:Microsoft.FSharp.Control.Async" /> type. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<namespacedoc><summary> Library functionality for asynchronous programming, events and agents. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">Asynchronous Programming</a>, <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/members/events">Events</a> and <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/lazy-expressions">Lazy Expressions</a> in the F# Language Guide. </summary></namespacedoc>
<category index="1">Async Programming</category>
static member Async.Sleep : dueTime:TimeSpan -> Async<unit>
static member Async.Sleep : millisecondsDueTime:int -> Async<unit>
static member Async.Sleep : millisecondsDueTime:int -> Async<unit>
val asyncPage : n:int -> Async<string []>
val n : int
val loop : (int -> 'a -> Async<string []>)
val n : 'a
val frontPageP : string
val pageDoc : HtmlDocument
val ParallelThrottled : xs:seq<Async<'a>> -> Async<'a []>
val xs : seq<Async<'a>>
static member Async.Parallel : computations:seq<Async<'T>> -> Async<'T []>
static member Async.Parallel : computations:seq<Async<'T>> * ?maxDegreeOfParallelism:int -> Async<'T []>
static member Async.Parallel : computations:seq<Async<'T>> * ?maxDegreeOfParallelism:int -> Async<'T []>
val asyncPages : pages:int list -> EarningsCall []
val pages : int list
type 'T list = List<'T>
<summary>The type of immutable singly-linked lists. </summary>
<remarks>See the <see cref="T:Microsoft.FSharp.Collections.ListModule" /> module for further operations related to lists. Use the constructors <c>[]</c> and <c>::</c> (infix) to create values of this type, or the notation <c>[1; 2; 3]</c>. Use the values in the <c>List</c> module to manipulate values of this type, or pattern match against the values directly. See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/lists">F# Language Guide - Lists</a>. </remarks>
<summary>The type of immutable singly-linked lists. </summary>
<remarks>See the <see cref="T:Microsoft.FSharp.Collections.ListModule" /> module for further operations related to lists. Use the constructors <c>[]</c> and <c>::</c> (infix) to create values of this type, or the notation <c>[1; 2; 3]</c>. Use the values in the <c>List</c> module to manipulate values of this type, or pattern match against the values directly. See also <a href="https://docs.microsoft.com/dotnet/fsharp/language-reference/lists">F# Language Guide - Lists</a>. </remarks>
val urls : string []
Multiple items
module Seq from Plotly.NET
--------------------
module Seq from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
module Seq from Plotly.NET
--------------------
module Seq from Microsoft.FSharp.Collections
<summary>Contains operations for working with values of type <see cref="T:Microsoft.FSharp.Collections.seq`1" />.</summary>
Multiple items
module Async from TranscriptParsing
--------------------
type Async = static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool> static member AwaitTask : task:Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool> static member CancelDefaultToken : unit -> unit static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>> static member Choice : computations:seq<Async<'T option>> -> Async<'T option> static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...
<summary>Holds static members for creating and manipulating asynchronous computations.</summary>
<remarks> See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<category index="1">Async Programming</category>
--------------------
type Async<'T> =
<summary> An asynchronous computation, which, when run, will eventually produce a value of type T, or else raises an exception. </summary>
<remarks> This type has no members. Asynchronous computations are normally specified either by using an async expression or the static methods in the <see cref="T:Microsoft.FSharp.Control.Async" /> type. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<namespacedoc><summary> Library functionality for asynchronous programming, events and agents. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">Asynchronous Programming</a>, <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/members/events">Events</a> and <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/lazy-expressions">Lazy Expressions</a> in the F# Language Guide. </summary></namespacedoc>
<category index="1">Async Programming</category>
module Async from TranscriptParsing
--------------------
type Async = static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool> static member AwaitTask : task:Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool> static member CancelDefaultToken : unit -> unit static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>> static member Choice : computations:seq<Async<'T option>> -> Async<'T option> static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...
<summary>Holds static members for creating and manipulating asynchronous computations.</summary>
<remarks> See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<category index="1">Async Programming</category>
--------------------
type Async<'T> =
<summary> An asynchronous computation, which, when run, will eventually produce a value of type T, or else raises an exception. </summary>
<remarks> This type has no members. Asynchronous computations are normally specified either by using an async expression or the static methods in the <see cref="T:Microsoft.FSharp.Control.Async" /> type. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<namespacedoc><summary> Library functionality for asynchronous programming, events and agents. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">Asynchronous Programming</a>, <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/members/events">Events</a> and <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/lazy-expressions">Lazy Expressions</a> in the F# Language Guide. </summary></namespacedoc>
<category index="1">Async Programming</category>
static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T
val collect : mapping:('T -> 'U []) -> array:'T [] -> 'U []
<summary>For each element of the array, applies the given function. Concatenates all the results and return the combined array.</summary>
<param name="mapping">The function to create sub-arrays from the input array elements.</param>
<param name="array">The input array.</param>
<returns>The concatenation of the sub-arrays.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
<summary>For each element of the array, applies the given function. Concatenates all the results and return the combined array.</summary>
<param name="mapping">The function to create sub-arrays from the input array elements.</param>
<param name="array">The input array.</param>
<returns>The concatenation of the sub-arrays.</returns>
<exception cref="T:System.ArgumentNullException">Thrown when the input array is null.</exception>
val id : x:'T -> 'T
<summary>The identity function</summary>
<param name="x">The input value.</param>
<returns>The same value.</returns>
<summary>The identity function</summary>
<param name="x">The input value.</param>
<returns>The same value.</returns>
val transcripts : EarningsCall []
val examplePages : EarningsCall []
namespace Newtonsoft
namespace Newtonsoft.Json
type Environment =
static member Exit : exitCode: int -> unit
static member ExpandEnvironmentVariables : name: string -> string
static member FailFast : message: string -> unit + 1 overload
static member GetCommandLineArgs : unit -> string []
static member GetEnvironmentVariable : variable: string -> string + 1 overload
static member GetEnvironmentVariables : unit -> IDictionary + 1 overload
static member GetFolderPath : folder: SpecialFolder -> string + 1 overload
static member GetLogicalDrives : unit -> string []
static member SetEnvironmentVariable : variable: string * value: string -> unit + 1 overload
static member CommandLine : string
...
<summary>Provides information about, and means to manipulate, the current environment and platform. This class cannot be inherited.</summary>
<summary>Provides information about, and means to manipulate, the current environment and platform. This class cannot be inherited.</summary>
property Environment.CurrentDirectory: string with get, set
<summary>Gets or sets the fully qualified path of the current working directory.</summary>
<exception cref="T:System.ArgumentException">Attempted to set to an empty string ("").</exception>
<exception cref="T:System.ArgumentNullException">Attempted to set to <see langword="null" />.</exception>
<exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
<exception cref="T:System.IO.DirectoryNotFoundException">Attempted to set a local path that cannot be found.</exception>
<exception cref="T:System.Security.SecurityException">The caller does not have the appropriate permission.</exception>
<returns>The directory path.</returns>
<summary>Gets or sets the fully qualified path of the current working directory.</summary>
<exception cref="T:System.ArgumentException">Attempted to set to an empty string ("").</exception>
<exception cref="T:System.ArgumentNullException">Attempted to set to <see langword="null" />.</exception>
<exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
<exception cref="T:System.IO.DirectoryNotFoundException">Attempted to set a local path that cannot be found.</exception>
<exception cref="T:System.Security.SecurityException">The caller does not have the appropriate permission.</exception>
<returns>The directory path.</returns>
val transcriptsToJson : fileName:string -> calls:EarningsCall [] -> unit
val fileName : string
val calls : EarningsCall []
type JsonConvert =
static member DeserializeAnonymousType<'T> : value: string * anonymousTypeObject: 'T -> 'T + 1 overload
static member DeserializeObject : value: string -> obj + 7 overloads
static member DeserializeXNode : value: string -> XDocument + 3 overloads
static member DeserializeXmlNode : value: string -> XmlDocument + 3 overloads
static member EnsureDecimalPlace : value: float * text: string -> string + 1 overload
static member EnsureFloatFormat : value: float * text: string * floatFormatHandling: FloatFormatHandling * quoteChar: char * nullable: bool -> string
static member PopulateObject : value: string * target: obj -> unit + 1 overload
static member SerializeObject : value: obj -> string + 7 overloads
static member SerializeObjectInternal : value: obj * type: Type * jsonSerializer: JsonSerializer -> string
static member SerializeXNode : node: XObject -> string + 2 overloads
...
<summary> Provides methods for converting between .NET types and JSON types. </summary>
<example><code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="SerializeObject" title="Serializing and Deserializing JSON with JsonConvert" /></example>
<summary> Provides methods for converting between .NET types and JSON types. </summary>
<example><code lang="cs" source="..\Src\Newtonsoft.Json.Tests\Documentation\SerializationTests.cs" region="SerializeObject" title="Serializing and Deserializing JSON with JsonConvert" /></example>
JsonConvert.SerializeObject(value: obj) : string
JsonConvert.SerializeObject(value: obj, settings: JsonSerializerSettings) : string
JsonConvert.SerializeObject(value: obj, [<ParamArray>] converters: JsonConverter []) : string
JsonConvert.SerializeObject(value: obj, formatting: Formatting) : string
JsonConvert.SerializeObject(value: obj, formatting: Formatting, settings: JsonSerializerSettings) : string
JsonConvert.SerializeObject(value: obj, type: Type, settings: JsonSerializerSettings) : string
JsonConvert.SerializeObject(value: obj, formatting: Formatting, [<ParamArray>] converters: JsonConverter []) : string
JsonConvert.SerializeObject(value: obj, type: Type, formatting: Formatting, settings: JsonSerializerSettings) : string
JsonConvert.SerializeObject(value: obj, settings: JsonSerializerSettings) : string
JsonConvert.SerializeObject(value: obj, [<ParamArray>] converters: JsonConverter []) : string
JsonConvert.SerializeObject(value: obj, formatting: Formatting) : string
JsonConvert.SerializeObject(value: obj, formatting: Formatting, settings: JsonSerializerSettings) : string
JsonConvert.SerializeObject(value: obj, type: Type, settings: JsonSerializerSettings) : string
JsonConvert.SerializeObject(value: obj, formatting: Formatting, [<ParamArray>] converters: JsonConverter []) : string
JsonConvert.SerializeObject(value: obj, type: Type, formatting: Formatting, settings: JsonSerializerSettings) : string
val json : string
namespace System.IO
type File =
static member AppendAllLines : path: string * contents: IEnumerable<string> -> unit + 1 overload
static member AppendAllLinesAsync : path: string * contents: IEnumerable<string> * encoding: Encoding *?cancellationToken: CancellationToken -> Task + 1 overload
static member AppendAllText : path: string * contents: string -> unit + 1 overload
static member AppendAllTextAsync : path: string * contents: string * encoding: Encoding *?cancellationToken: CancellationToken -> Task + 1 overload
static member AppendText : path: string -> StreamWriter
static member Copy : sourceFileName: string * destFileName: string -> unit + 1 overload
static member Create : path: string -> FileStream + 2 overloads
static member CreateText : path: string -> StreamWriter
static member Decrypt : path: string -> unit
static member Delete : path: string -> unit
...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
IO.File.WriteAllText(path: string, contents: string) : unit
IO.File.WriteAllText(path: string, contents: string, encoding: Text.Encoding) : unit
IO.File.WriteAllText(path: string, contents: string, encoding: Text.Encoding) : unit