diff --git a/Src/Newtonsoft.Json.Tests/Converters/XmlNodeConverterTest.cs b/Src/Newtonsoft.Json.Tests/Converters/XmlNodeConverterTest.cs index 5937a700..619636b4 100644 --- a/Src/Newtonsoft.Json.Tests/Converters/XmlNodeConverterTest.cs +++ b/Src/Newtonsoft.Json.Tests/Converters/XmlNodeConverterTest.cs @@ -141,6 +141,24 @@ namespace Newtonsoft.Json.Tests.Converters json = JsonConvert.SerializeXNode(doc1, Formatting.Indented, true); Assert.AreEqual("null", json); } + + [Test] + public void SerializeAndDeserializeXmlWithNamespaceInChildrenAndNoValueInChildren() + { + var xmlString = @" + + AAA + adad + "; + + var xml = XElement.Parse(xmlString); + + var json1 = JsonConvert.SerializeXNode(xml); + var xmlBack = JsonConvert.DeserializeObject(json1); + + var equals = XElement.DeepEquals(xmlBack, xml); + Assert.IsTrue(equals); + } #endif [Test] diff --git a/Src/Newtonsoft.Json.Tests/Linq/JsonPath/JPathExecuteTests.cs b/Src/Newtonsoft.Json.Tests/Linq/JsonPath/JPathExecuteTests.cs index 7f07085b..81952314 100644 --- a/Src/Newtonsoft.Json.Tests/Linq/JsonPath/JPathExecuteTests.cs +++ b/Src/Newtonsoft.Json.Tests/Linq/JsonPath/JPathExecuteTests.cs @@ -50,6 +50,16 @@ namespace Newtonsoft.Json.Tests.Linq.JsonPath [TestFixture] public class JPathExecuteTests : TestFixtureBase { + [Test] + public void EvaluateEmptyPropertyIndexer() + { + JObject o = new JObject( + new JProperty("", 1)); + + JToken t = o.SelectToken("['']"); + Assert.AreEqual(1, (int)t); + } + [Test] public void EvaluateEmptyString() { @@ -58,6 +68,19 @@ namespace Newtonsoft.Json.Tests.Linq.JsonPath JToken t = o.SelectToken(""); Assert.AreEqual(o, t); + + t = o.SelectToken("['']"); + Assert.AreEqual(null, t); + } + + [Test] + public void EvaluateEmptyStringWithMatchingEmptyProperty() + { + JObject o = new JObject( + new JProperty(" ", 1)); + + JToken t = o.SelectToken("[' ']"); + Assert.AreEqual(1, (int)t); } [Test] diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net35.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net35.csproj index 313dc6e9..05633c52 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net35.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net35.csproj @@ -140,6 +140,7 @@ + diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net40.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net40.csproj index e137e0fd..d7fa9a92 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net40.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Net40.csproj @@ -66,6 +66,10 @@ AllRules.ruleset + + False + ..\packages\FSharp.Core.4.0.0\lib\FSharp.Core.dll + False @@ -258,6 +262,7 @@ + diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable.csproj index 42f7caa6..73528136 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable.csproj @@ -67,6 +67,10 @@ false + + False + ..\packages\FSharp.Core.4.0.0\lib\FSharp.Core.dll + ..\packages\NUnit.2.6.2\lib\nunit.framework.dll @@ -142,6 +146,7 @@ + diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable40.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable40.csproj index 9ac4fd92..e3293651 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable40.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.Portable40.csproj @@ -67,6 +67,10 @@ false + + False + ..\packages\FSharp.Core.4.0.0\lib\FSharp.Core.dll + False @@ -138,6 +142,7 @@ + diff --git a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj index 02e75a34..fee4e78f 100644 --- a/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj +++ b/Src/Newtonsoft.Json.Tests/Newtonsoft.Json.Tests.csproj @@ -30,6 +30,10 @@ 4 + + False + ..\packages\FSharp.Core.4.0.0\lib\FSharp.Core.dll + False ..\packages\NUnit.2.6.2\lib\nunit.framework.dll @@ -233,6 +237,7 @@ + diff --git a/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs b/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs index 380b1a6f..2327e9ff 100644 --- a/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs +++ b/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs @@ -75,4 +75,4 @@ using System.Security; // by using the '*' as shown below: [assembly: AssemblyVersion("6.0.0.0")] -[assembly: AssemblyFileVersion("6.0.1.17101")] +[assembly: AssemblyFileVersion("6.0.1.17109")] diff --git a/Src/Newtonsoft.Json.Tests/Serialization/FSharpTests.cs b/Src/Newtonsoft.Json.Tests/Serialization/FSharpTests.cs new file mode 100644 index 00000000..1ac1fe20 --- /dev/null +++ b/Src/Newtonsoft.Json.Tests/Serialization/FSharpTests.cs @@ -0,0 +1,94 @@ +#region License +// Copyright (c) 2007 James Newton-King +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +#endregion + +#if !(NET35 || NET20 || NETFX_CORE) +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Microsoft.FSharp.Collections; +using NUnit.Framework; + +namespace Newtonsoft.Json.Tests.Serialization +{ + [TestFixture] + public class FSharpTests : TestFixtureBase + { + [Test] + public void List() + { + FSharpList l = ListModule.OfSeq(new List {1,2,3}); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + + Assert.AreEqual(@"[ + 1, + 2, + 3 +]", json); + + FSharpList l2 = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(l.Length, l2.Length); + CollectionAssert.AreEquivalent(l, l2); + } + + [Test] + public void Set() + { + FSharpSet l = SetModule.OfSeq(new List { 1, 2, 3 }); + + string json = JsonConvert.SerializeObject(l, Formatting.Indented); + + Assert.AreEqual(@"[ + 1, + 2, + 3 +]", json); + + FSharpSet l2 = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(l.Count, l2.Count); + CollectionAssert.AreEquivalent(l, l2); + } + + [Test] + public void Map() + { + FSharpMap m1 = MapModule.OfSeq(new List> { Tuple.Create("one", 1), Tuple.Create("II", 2), Tuple.Create("3", 3) }); + + string json = JsonConvert.SerializeObject(m1, Formatting.Indented); + + FSharpMap m2 = JsonConvert.DeserializeObject>(json); + + Assert.AreEqual(m1.Count, m2.Count); + Assert.AreEqual(1, m2["one"]); + Assert.AreEqual(2, m2["II"]); + Assert.AreEqual(3, m2["3"]); + } + } +} +#endif \ No newline at end of file diff --git a/Src/Newtonsoft.Json.Tests/packages.config b/Src/Newtonsoft.Json.Tests/packages.config index 1e7b38fd..3f4320f3 100644 --- a/Src/Newtonsoft.Json.Tests/packages.config +++ b/Src/Newtonsoft.Json.Tests/packages.config @@ -1,5 +1,6 @@  + \ No newline at end of file diff --git a/Src/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs b/Src/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs index 11b68fa8..979fc38e 100644 --- a/Src/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs +++ b/Src/Newtonsoft.Json/Converters/DiscriminatedUnionConverter.cs @@ -23,6 +23,7 @@ // OTHER DEALINGS IN THE SOFTWARE. #endregion +#if !(NET35 || NET20 || NETFX_CORE) using System; using System.Collections; using System.Collections.Generic; @@ -44,16 +45,6 @@ namespace Newtonsoft.Json.Converters /// public class DiscriminatedUnionConverter : JsonConverter { - private static bool _initialized; - private static MethodCall _isUnion; - private static MethodCall _getUnionFields; - private static MethodCall _getUnionCases; - private static MethodCall _makeUnion; - private static Func _getUnionCaseInfoName; - private static Func _getUnionCaseInfo; - private static Func _getUnionCaseFields; - private static MethodCall _getUnionCaseInfoFields; - private const string CasePropertyName = "Case"; private const string FieldsPropertyName = "Fields"; @@ -69,10 +60,10 @@ namespace Newtonsoft.Json.Converters Type t = value.GetType(); - object result = _getUnionFields(null, value, t, null); - object info = _getUnionCaseInfo(result); - object fields = _getUnionCaseFields(result); - object caseName = _getUnionCaseInfoName(info); + object result = FSharpUtils.GetUnionFields(null, value, t, null); + object info = FSharpUtils.GetUnionCaseInfo(result); + object fields = FSharpUtils.GetUnionCaseFields(result); + object caseName = FSharpUtils.GetUnionCaseInfoName(info); writer.WriteStartObject(); writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(CasePropertyName) : CasePropertyName); @@ -95,7 +86,7 @@ namespace Newtonsoft.Json.Converters if (reader.TokenType == JsonToken.Null) return null; - IEnumerable cases = (IEnumerable)_getUnionCases(null, objectType, null); + IEnumerable cases = (IEnumerable)FSharpUtils.GetUnionCases(null, objectType, null); ReadAndAssertProperty(reader, CasePropertyName); ReadAndAssert(reader); @@ -105,7 +96,7 @@ namespace Newtonsoft.Json.Converters object matchingCaseInfo = null; foreach (object c in cases) { - if ((string)_getUnionCaseInfoName(c) == caseName) + if ((string)FSharpUtils.GetUnionCaseInfoName(c) == caseName) { matchingCaseInfo = c; break; @@ -121,7 +112,7 @@ namespace Newtonsoft.Json.Converters // first value ReadAndAssert(reader); - PropertyInfo[] fieldProperties = (PropertyInfo[])_getUnionCaseInfoFields(matchingCaseInfo); + PropertyInfo[] fieldProperties = (PropertyInfo[])FSharpUtils.GetUnionCaseInfoFields(matchingCaseInfo); List fieldValues = new List(); foreach (PropertyInfo field in fieldProperties) { @@ -132,7 +123,7 @@ namespace Newtonsoft.Json.Converters // end object ReadAndAssert(reader); - return _makeUnion(null, matchingCaseInfo, fieldValues.ToArray(), null); + return FSharpUtils.MakeUnion(null, matchingCaseInfo, fieldValues.ToArray(), null); } /// @@ -161,7 +152,7 @@ namespace Newtonsoft.Json.Converters Type attributeType = attribute.GetType(); if (attributeType.Name == "CompilationMappingAttribute") { - EnsureInitialized(attributeType); + FSharpUtils.EnsureInitialized(attributeType.Assembly()); isFSharpType = true; break; @@ -171,40 +162,7 @@ namespace Newtonsoft.Json.Converters if (!isFSharpType) return false; - return (bool)_isUnion(null, objectType, null); - } - - private static void EnsureInitialized(Type attributeType) - { - if (!_initialized) - { - _initialized = true; - - Assembly fsharpCoreAssembly = attributeType.Assembly(); - Type fsharpType = fsharpCoreAssembly.GetType("Microsoft.FSharp.Reflection.FSharpType"); - - MethodInfo isUnionMethodInfo = fsharpType.GetMethod("IsUnion", BindingFlags.Public | BindingFlags.Static); - _isUnion = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(isUnionMethodInfo); - - MethodInfo getUnionCasesMethodInfo = fsharpType.GetMethod("GetUnionCases", BindingFlags.Public | BindingFlags.Static); - _getUnionCases = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(getUnionCasesMethodInfo); - - Type fsharpValue = fsharpCoreAssembly.GetType("Microsoft.FSharp.Reflection.FSharpValue"); - - MethodInfo getUnionFieldsMethodInfo = fsharpValue.GetMethod("GetUnionFields", BindingFlags.Public | BindingFlags.Static); - _getUnionFields = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(getUnionFieldsMethodInfo); - - _getUnionCaseInfo = JsonTypeReflector.ReflectionDelegateFactory.CreateGet(getUnionFieldsMethodInfo.ReturnType.GetProperty("Item1")); - _getUnionCaseFields = JsonTypeReflector.ReflectionDelegateFactory.CreateGet(getUnionFieldsMethodInfo.ReturnType.GetProperty("Item2")); - - MethodInfo makeUnionMethodInfo = fsharpValue.GetMethod("MakeUnion", BindingFlags.Public | BindingFlags.Static); - _makeUnion = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(makeUnionMethodInfo); - - Type unionCaseInfo = fsharpCoreAssembly.GetType("Microsoft.FSharp.Reflection.UnionCaseInfo"); - - _getUnionCaseInfoName = JsonTypeReflector.ReflectionDelegateFactory.CreateGet(unionCaseInfo.GetProperty("Name")); - _getUnionCaseInfoFields = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(unionCaseInfo.GetMethod("GetFields")); - } + return (bool)FSharpUtils.IsUnion(null, objectType, null); } private static void ReadAndAssertProperty(JsonReader reader, string propertyName) @@ -221,4 +179,5 @@ namespace Newtonsoft.Json.Converters throw new JsonSerializationException("Unexpected end."); } } -} \ No newline at end of file +} +#endif \ No newline at end of file diff --git a/Src/Newtonsoft.Json/Converters/XmlNodeConverter.cs b/Src/Newtonsoft.Json/Converters/XmlNodeConverter.cs index 3fa91b0d..62ba4d45 100644 --- a/Src/Newtonsoft.Json/Converters/XmlNodeConverter.cs +++ b/Src/Newtonsoft.Json/Converters/XmlNodeConverter.cs @@ -1234,8 +1234,9 @@ namespace Newtonsoft.Json.Converters manager.PushScope(); DeserializeNode(reader, document, manager, element); manager.PopScope(); - manager.RemoveNamespace(string.Empty, manager.DefaultNamespace); } + + manager.RemoveNamespace(string.Empty, manager.DefaultNamespace); } } } diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.Net35.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.Net35.csproj index 2127a17f..3da55f7b 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.Net35.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.Net35.csproj @@ -241,6 +241,7 @@ + diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.Net40.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.Net40.csproj index 77e02e7d..37ff4285 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.Net40.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.Net40.csproj @@ -241,6 +241,7 @@ + diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.Portable.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.Portable.csproj index a9839d9e..95bca0fe 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.Portable.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.Portable.csproj @@ -213,6 +213,7 @@ + diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.Portable40.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.Portable40.csproj index be6fe45f..d172f8bc 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.Portable40.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.Portable40.csproj @@ -218,6 +218,7 @@ + diff --git a/Src/Newtonsoft.Json/Newtonsoft.Json.csproj b/Src/Newtonsoft.Json/Newtonsoft.Json.csproj index 530e065f..52f5d685 100644 --- a/Src/Newtonsoft.Json/Newtonsoft.Json.csproj +++ b/Src/Newtonsoft.Json/Newtonsoft.Json.csproj @@ -217,6 +217,7 @@ + diff --git a/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs b/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs index f728fa4b..9c17f1b5 100644 --- a/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs +++ b/Src/Newtonsoft.Json/Properties/AssemblyInfo.cs @@ -91,5 +91,5 @@ using System.Security; // by using the '*' as shown below: [assembly: AssemblyVersion("6.0.0.0")] -[assembly: AssemblyFileVersion("6.0.1.17101")] +[assembly: AssemblyFileVersion("6.0.1.17109")] [assembly: CLSCompliant(true)] diff --git a/Src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs b/Src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs index a0b9db09..4394d913 100644 --- a/Src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs +++ b/Src/Newtonsoft.Json/Serialization/DefaultContractResolver.cs @@ -113,11 +113,13 @@ namespace Newtonsoft.Json.Serialization #endif #if NETFX_CORE new JsonValueConverter(), +#endif +#if !(NET35 || NET20 || NETFX_CORE) + new DiscriminatedUnionConverter(), #endif new KeyValuePairConverter(), new BsonObjectIdConverter(), - new RegexConverter(), - new DiscriminatedUnionConverter() + new RegexConverter() }; private static Dictionary _sharedContractCache; @@ -721,29 +723,41 @@ namespace Newtonsoft.Json.Serialization if (onSerializing != null) { -#if NETFX_CORE - if (!t.IsGenericType() || (t.GetGenericTypeDefinition() != typeof(ConcurrentDictionary<,>))) - contract.OnSerializingCallbacks.AddRange(onSerializing); -#else - contract.OnSerializingCallbacks.AddRange(onSerializing); +#if !(NET35 || NET20 || NETFX_CORE) + if (t.Name != FSharpUtils.FSharpSetTypeName && t.Name != FSharpUtils.FSharpMapTypeName) #endif + { +#if NETFX_CORE + if (!t.IsGenericType() || (t.GetGenericTypeDefinition() != typeof(ConcurrentDictionary<,>))) + contract.OnSerializingCallbacks.AddRange(onSerializing); +#else + contract.OnSerializingCallbacks.AddRange(onSerializing); +#endif + } } if (onSerialized != null) contract.OnSerializedCallbacks.AddRange(onSerialized); if (onDeserializing != null) + { contract.OnDeserializingCallbacks.AddRange(onDeserializing); + } if (onDeserialized != null) { - // ConcurrentDictionary throws an error here so don't use its OnDeserialized - http://json.codeplex.com/discussions/257093 -#if !(NET35 || NET20 || PORTABLE || PORTABLE40) - if (!t.IsGenericType() || (t.GetGenericTypeDefinition() != typeof(ConcurrentDictionary<,>))) - contract.OnDeserializedCallbacks.AddRange(onDeserialized); -#else - contract.OnDeserializedCallbacks.AddRange(onDeserialized); +#if !(NET35 || NET20 || NETFX_CORE) + if (t.Name != FSharpUtils.FSharpSetTypeName && t.Name != FSharpUtils.FSharpMapTypeName) #endif + { + // ConcurrentDictionary throws an error here so don't use its OnDeserialized - http://json.codeplex.com/discussions/257093 +#if !(NET35 || NET20 || PORTABLE || PORTABLE40) + if (!t.IsGenericType() || (t.GetGenericTypeDefinition() != typeof(ConcurrentDictionary<,>))) + contract.OnDeserializedCallbacks.AddRange(onDeserialized); +#else + contract.OnDeserializedCallbacks.AddRange(onDeserialized); +#endif + } } if (onError != null) diff --git a/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs b/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs index 29d4d4bb..5b1ae356 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonArrayContract.cs @@ -148,6 +148,14 @@ namespace Newtonsoft.Json.Serialization ParametrizedConstructor = CollectionUtils.ResolveEnumableCollectionConstructor(underlyingType, CollectionItemType); +#if !(NET35 || NET20 || NETFX_CORE) + if (ParametrizedConstructor == null && underlyingType.Name == FSharpUtils.FSharpListTypeName) + { + FSharpUtils.EnsureInitialized(underlyingType.Assembly()); + ParametrizedConstructor = FSharpUtils.CreateSeq(CollectionItemType); + } +#endif + if (underlyingType.IsGenericType() && underlyingType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) { _genericCollectionDefinitionType = tempCollectionType; diff --git a/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs b/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs index 8fac58fe..9f08d930 100644 --- a/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs +++ b/Src/Newtonsoft.Json/Serialization/JsonDictionaryContract.cs @@ -117,8 +117,18 @@ namespace Newtonsoft.Json.Serialization } if (keyType != null && valueType != null) + { ParametrizedConstructor = CollectionUtils.ResolveEnumableCollectionConstructor(CreatedType, typeof(KeyValuePair<,>).MakeGenericType(keyType, valueType)); +#if !(NET35 || NET20 || NETFX_CORE) + if (ParametrizedConstructor == null && underlyingType.Name == FSharpUtils.FSharpMapTypeName) + { + FSharpUtils.EnsureInitialized(underlyingType.Assembly()); + ParametrizedConstructor = FSharpUtils.CreateMap(keyType, valueType); + } +#endif + } + ShouldCreateWrapper = !typeof(IDictionary).IsAssignableFrom(CreatedType); DictionaryKeyType = keyType; diff --git a/Src/Newtonsoft.Json/Utilities/FSharpUtils.cs b/Src/Newtonsoft.Json/Utilities/FSharpUtils.cs new file mode 100644 index 00000000..5c8e1d8e --- /dev/null +++ b/Src/Newtonsoft.Json/Utilities/FSharpUtils.cs @@ -0,0 +1,144 @@ +#region License +// Copyright (c) 2007 James Newton-King +// +// Permission is hereby granted, free of charge, to any person +// obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without +// restriction, including without limitation the rights to use, +// copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the +// Software is furnished to do so, subject to the following +// conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +// OTHER DEALINGS IN THE SOFTWARE. +#endregion + +#if !(NET35 || NET20 || NETFX_CORE) +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using Newtonsoft.Json.Serialization; + +namespace Newtonsoft.Json.Utilities +{ + internal static class FSharpUtils + { + private static bool _initialized; + private static MethodInfo _ofSeq; + + public static Assembly FSharpCoreAssembly { get; private set; } + public static MethodCall IsUnion { get; private set; } + public static MethodCall GetUnionFields { get; private set; } + public static MethodCall GetUnionCases { get; private set; } + public static MethodCall MakeUnion { get; private set; } + public static Func GetUnionCaseInfoName { get; private set; } + public static Func GetUnionCaseInfo { get; private set; } + public static Func GetUnionCaseFields { get; private set; } + public static MethodCall GetUnionCaseInfoFields { get; private set; } + + public const string FSharpSetTypeName = "FSharpSet`1"; + public const string FSharpListTypeName = "FSharpList`1"; + public const string FSharpMapTypeName = "FSharpMap`2"; + + public static void EnsureInitialized(Assembly fsharpCoreAssembly) + { + if (!_initialized) + { + FSharpCoreAssembly = fsharpCoreAssembly; + + Type fsharpType = fsharpCoreAssembly.GetType("Microsoft.FSharp.Reflection.FSharpType"); + + MethodInfo isUnionMethodInfo = fsharpType.GetMethod("IsUnion", BindingFlags.Public | BindingFlags.Static); + IsUnion = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(isUnionMethodInfo); + + MethodInfo getUnionCasesMethodInfo = fsharpType.GetMethod("GetUnionCases", BindingFlags.Public | BindingFlags.Static); + GetUnionCases = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(getUnionCasesMethodInfo); + + Type fsharpValue = fsharpCoreAssembly.GetType("Microsoft.FSharp.Reflection.FSharpValue"); + + MethodInfo getUnionFieldsMethodInfo = fsharpValue.GetMethod("GetUnionFields", BindingFlags.Public | BindingFlags.Static); + GetUnionFields = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(getUnionFieldsMethodInfo); + + GetUnionCaseInfo = JsonTypeReflector.ReflectionDelegateFactory.CreateGet(getUnionFieldsMethodInfo.ReturnType.GetProperty("Item1")); + GetUnionCaseFields = JsonTypeReflector.ReflectionDelegateFactory.CreateGet(getUnionFieldsMethodInfo.ReturnType.GetProperty("Item2")); + + MethodInfo makeUnionMethodInfo = fsharpValue.GetMethod("MakeUnion", BindingFlags.Public | BindingFlags.Static); + MakeUnion = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(makeUnionMethodInfo); + + Type unionCaseInfo = fsharpCoreAssembly.GetType("Microsoft.FSharp.Reflection.UnionCaseInfo"); + + GetUnionCaseInfoName = JsonTypeReflector.ReflectionDelegateFactory.CreateGet(unionCaseInfo.GetProperty("Name")); + GetUnionCaseInfoFields = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(unionCaseInfo.GetMethod("GetFields")); + + Type listModule = fsharpCoreAssembly.GetType("Microsoft.FSharp.Collections.ListModule"); + _ofSeq = listModule.GetMethod("OfSeq"); + + _initialized = true; + } + } + + public static MethodInfo CreateSeq(Type t) + { + MethodInfo seqType = _ofSeq.MakeGenericMethod(t); + + return seqType; + } + + public static MethodInfo CreateMap(Type keyType, Type valueType) + { + Type t = typeof(FSharpMapCreator<,>).MakeGenericType(keyType, valueType); + + MethodInfo initializeMethod = t.GetMethod("EnsureInitialized"); + + initializeMethod.Invoke(null, new object[] { FSharpCoreAssembly }); + + MethodInfo typedCreateMethod = t.GetMethod("CreateMapGeneric"); + + return typedCreateMethod; + } + + } + + internal static class FSharpMapCreator + { + private static bool _initialized; + private static MethodCall _createMap; + + public static void EnsureInitialized(Assembly fsharpCoreAssembly) + { + if (!_initialized) + { + Type mapType = fsharpCoreAssembly.GetType("Microsoft.FSharp.Collections.FSharpMap`2"); + + Type genericMapType = mapType.MakeGenericType(typeof(TKey), typeof(TValue)); + + ConstructorInfo ctor = genericMapType.GetConstructor(new[] { typeof(IEnumerable>) }); + + _createMap = JsonTypeReflector.ReflectionDelegateFactory.CreateMethodCall(ctor); + + _initialized = true; + } + } + + public static object CreateMapGeneric(IEnumerable> values) + { + IEnumerable> tupleValues = values.Select(kv => new Tuple(kv.Key, kv.Value)); + + object map = _createMap(null, tupleValues); + return map; + } + } +} +#endif \ No newline at end of file diff --git a/Src/packages/FSharp.Core.4.0.0/FSharp.Core.4.0.0.nupkg b/Src/packages/FSharp.Core.4.0.0/FSharp.Core.4.0.0.nupkg new file mode 100644 index 00000000..e0b614e9 Binary files /dev/null and b/Src/packages/FSharp.Core.4.0.0/FSharp.Core.4.0.0.nupkg differ diff --git a/Src/packages/FSharp.Core.4.0.0/FSharp.Core.4.0.0.nuspec b/Src/packages/FSharp.Core.4.0.0/FSharp.Core.4.0.0.nuspec new file mode 100644 index 00000000..12c62830 --- /dev/null +++ b/Src/packages/FSharp.Core.4.0.0/FSharp.Core.4.0.0.nuspec @@ -0,0 +1,16 @@ + + + + FSharp.Core + 4.0.0 + FSharp.Core + Microsoft + Microsoft + false + FSharp.Core.dll + V 4.0.0 + Copyright 2012 + + f# + + \ No newline at end of file diff --git a/Src/packages/FSharp.Core.4.0.0/lib/FSharp.Core.dll b/Src/packages/FSharp.Core.4.0.0/lib/FSharp.Core.dll new file mode 100644 index 00000000..1b9afb66 Binary files /dev/null and b/Src/packages/FSharp.Core.4.0.0/lib/FSharp.Core.dll differ diff --git a/Src/packages/FSharp.Core.4.0.0/lib/FSharp.Core.xml b/Src/packages/FSharp.Core.4.0.0/lib/FSharp.Core.xml new file mode 100644 index 00000000..533c5f5f --- /dev/null +++ b/Src/packages/FSharp.Core.4.0.0/lib/FSharp.Core.xml @@ -0,0 +1,8809 @@ + + +FSharp.Core + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the tail of the list, which is a list containing all the elements of the list, excluding the first element + + + Gets the number of items contained in the list + + + Gets the element of the list at the given position. + Lists are represented as linked lists so this is an O(n) operation. + The index. + The value at the given index. + + + Gets a value indicating if the list contains no entries + + + Gets the first element of the list + + + Returns an empty list of a particular type + + + Returns a list with head as its first element and tail as its subsequent elements + A new head value for the list. + The existing list. + The list with head appended to the front of tail. + + + The type of immutable singly-linked 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. + + + Lookup an element in the map. Raise KeyNotFoundException if no binding + exists in the map. + The input key. + Thrown when the key is not found. + The value mapped to the key. + + + Returns true if there are no bindings in the map. + + + The number of bindings in the map. + + + Lookup an element in the map, returning a Some value if the element is in the domain + of the map and None if not. + The input key. + The mapped value, or None if the key is not in the map. + + + Removes an element from the domain of the map. No exception is raised if the element is not present. + The input key. + The resulting map. + + + + + + Tests if an element is in the domain of the map. + The input key. + True if the map contains the given key. + + + Returns a new map with the binding added to the given map. + The input key. + The resulting map. + + + Builds a map that contains the bindings of the given IEnumerable. + The input sequence of key/value pairs. + The resulting map. + + + Immutable maps. Keys are ordered by F# generic comparison. + + Maps based on generic comparison are efficient for small keys. They are not a suitable choice if keys are recursive data structures + or if keys require bespoke comparison semantics. + + All members of this class are thread-safe and may be used concurrently from multiple threads. + + + An abbreviation for the CLI type System.Collections.Generic.List<_> + + + Returns a new set with the elements of the second set removed from the first. + The first input set. + The second input set. + A set containing elements of the first set that are not contained in the second set. + + + Compute the union of the two sets. + The first input set. + The second input set. + The union of the two input sets. + + + Returns the lowest element in the set according to the ordering being used for the set. + + + Returns the highest element in the set according to the ordering being used for the set. + + + A useful shortcut for Set.isEmpty. See the Set module for further operations on sets. + + + The number of elements in the set + + + A useful shortcut for Set.remove. Note this operation produces a new set + and does not mutate the original set. The new set will share many storage + nodes with the original. See the Set module for further operations on sets. + The value to remove from the set. + The result set. + + + Evaluates to "true" if all elements of the second set are in the first. + The set to test against. + True if this set is a superset of otherSet. + + + Evaluates to "true" if all elements of the first set are in the second. + The set to test against. + True if this set is a subset of otherSet. + + + Evaluates to "true" if all elements of the second set are in the first, and at least + one element of the first is not in the second. + The set to test against. + True if this set is a proper superset of otherSet. + + + Evaluates to "true" if all elements of the first set are in the second, and at least + one element of the second is not in the first. + The set to test against. + True if this set is a proper subset of otherSet. + + + + + + A useful shortcut for Set.contains. See the Set module for further operations on sets. + The value to check. + True if the set contains value. + + + A useful shortcut for Set.add. Note this operation produces a new set + and does not mutate the original set. The new set will share many storage + nodes with the original. See the Set module for further operations on sets. + The value to add to the set. + The result set. + + + Create a set containing elements drawn from the given sequence. + The input sequence. + The result set. + + + Immutable sets based on binary trees, where comparison is the + F# structural comparison function, potentially using implementations + of the IComparable interface on key values. + + See the Set module for further operations on sets. + + All members of this class are thread-safe and may be used concurrently from multiple threads. + + + An abbreviation for the type of immutable singly-linked 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. + + + An abbreviation for the CLI type System.Collections.Generic.IEnumerable<_> + + + Fetches an element from a 2D array. You can also use the syntax array.[index1,index2]. + + The input array. + The index along the first dimension. + The index along the second dimension. + + The value of the array at the given index. + Thrown when the indices are negative or exceed the bounds of the array. + + + Sets the value of an element in an array. You can also use the syntax array.[index1,index2] <- value. + + The input array. + The index along the first dimension. + The index along the second dimension. + The value to set in the array. + Thrown when the indices are negative or exceed the bounds of the array. + + + Builds a new array whose elements are the same as the input array but + where a non-zero-based input array generates a corresponding zero-based + output array. + + The input array. + + The zero-based output array. + + + Builds a new array whose elements are the results of applying the given function + to each of the elements of the array. The integer indices passed to the + function indicates the element being transformed. + + For non-zero-based arrays the basing on an input array will be propagated to the output + array. + + A function that is applied to transform each element of the array. The two integers + provide the index of the element. + The input array. + + An array whose elements have been transformed by the given mapping. + + + Builds a new array whose elements are the results of applying the given function + to each of the elements of the array. + + For non-zero-based arrays the basing on an input array will be propogated to the output + array. + + A function that is applied to transform each item of the input array. + The input array. + + An array whose elements have been transformed by the given mapping. + + + Returns the length of an array in the second dimension. + + The input array. + + The length of the array in the second dimension. + + + Returns the length of an array in the first dimension. + + The input array. + + The length of the array in the first dimension. + + + Applies the given function to each element of the array. The integer indices passed to the + function indicates the index of element. + + A function to apply to each element of the array with the indices available as an argument. + The input array. + + + Applies the given function to each element of the array. + + A function to apply to each element of the array. + The input array. + + + Creates a based array where the entries are initially Unchecked.defaultof<'T>. + + The base for the first dimension of the array. + The base for the second dimension of the array. + The length of the first dimension of the array. + The length of the second dimension of the array. + + The created array. + Thrown when base1, base2, length1, or length2 is negative. + + + Creates a based array whose elements are all initially the given value. + + The base for the first dimension of the array. + The base for the second dimension of the array. + The length of the first dimension of the array. + The length of the second dimension of the array. + The value to populate the new array. + + The created array. + Thrown when base1, base2, length1, or length2 is negative. + + + Creates a based array given the dimensions and a generator function to compute the elements. + + The base for the first dimension of the array. + The base for the second dimension of the array. + The length of the first dimension of the array. + The length of the second dimension of the array. + A function to produce elements of the array given the two indices. + + The created array. + Thrown when base1, base2, length1, or length2 is negative. + + + Creates an array where the entries are initially Unchecked.defaultof<'T>. + + The length of the first dimension of the array. + The length of the second dimension of the array. + + The created array. + Thrown when length1 or length2 is negative. + + + Creates an array whose elements are all initially the given value. + + The length of the first dimension of the array. + The length of the second dimension of the array. + The value to populate the new array. + + The created array. + Thrown when length1 or length2 is negative. + + + Creates an array given the dimensions and a generator function to compute the elements. + + The length of the first dimension of the array. + The length of the second dimension of the array. + A function to produce elements of the array given the two indices. + + The generated array. + Thrown when either of the lengths is negative. + + + Reads a range of elements from the first array and write them into the second. + + The source array. + The first-dimension index to begin copying from in the source array. + The second-dimension index to begin copying from in the source array. + The target array. + The first-dimension index to begin copying into in the target array. + The second-dimension index to begin copying into in the target array. + The number of elements to copy across the first dimension of the arrays. + The number of elements to copy across the second dimension of the arrays. + Thrown when any of the indices are negative or if either of + the counts are larger than the dimensions of the array allow. + + + Builds a new array whose elements are the same as the input array. + + For non-zero-based arrays the basing on an input array will be propogated to the output + array. + + The input array. + + A copy of the input array. + + + Fetches the base-index for the second dimension of the array. + + The input array. + + The base-index of the second dimension of the array. + + + Fetches the base-index for the first dimension of the array. + + The input array. + + The base-index of the first dimension of the array. + + + Basic operations on 2-dimensional arrays. + + F# and CLI multi-dimensional arrays are typically zero-based. + However, CLI multi-dimensional arrays used in conjunction with external + libraries (e.g. libraries associated with Visual Basic) be + non-zero based, using a potentially different base for each dimension. + The operations in this module will accept such arrays, and + the basing on an input array will be propagated to a matching output + array on the Array2D.map and Array2D.mapi operations. + Non-zero-based arrays can also be created using Array2D.zeroCreateBased, + Array2D.createBased and Array2D.initBased. + + + Creates an array where the entries are initially the "default" value. + The length of the first dimension. + The length of the second dimension. + The length of the third dimension. + The created array. + + + Sets the value of an element in an array. You can also + use the syntax 'array.[index1,index2,index3] <- value'. + The input array. + The index along the first dimension. + The index along the second dimension. + The index along the third dimension. + The value to set at the given index. + + + Builds a new array whose elements are the results of applying the given function + to each of the elements of the array. The integer indices passed to the + function indicates the element being transformed. + + For non-zero-based arrays the basing on an input array will be propogated to the output + array. + The function to transform the elements at each index in the array. + The input array. + The array created from the transformed elements. + + + Builds a new array whose elements are the results of applying the given function + to each of the elements of the array. + + For non-zero-based arrays the basing on an input array will be propogated to the output + array. + The function to transform each element of the array. + The input array. + The array created from the transformed elements. + + + Returns the length of an array in the third dimension. + The input array. + The length of the array in the third dimension. + + + Returns the length of an array in the second dimension. + The input array. + The length of the array in the second dimension. + + + Returns the length of an array in the first dimension + The input array. + The length of the array in the first dimension. + + + Applies the given function to each element of the array. The integer indicies passed to the + function indicates the index of element. + The function to apply to each element of the array. + The input array. + + + Applies the given function to each element of the array. + The function to apply to each element of the array. + The input array. + + + Fetches an element from a 3D array. You can also use the syntax 'array.[index1,index2,index3]' + The input array. + The index along the first dimension. + The index along the second dimension. + The index along the third dimension. + The value at the given index. + + + Creates an array given the dimensions and a generator function to compute the elements. + The length of the first dimension. + The length of the second dimension. + The length of the third dimension. + The function to create an initial value at each index into the array. + The created array. + + + Creates an array whose elements are all initially the given value. + The length of the first dimension. + The length of the second dimension. + The length of the third dimension. + The value of the array elements. + The created array. + + + Basic operations on rank 3 arrays. + + + Sets the value of an element in an array. You can also + use the syntax 'array.[index1,index2,index3,index4] <- value'. + The input array. + The index along the first dimension. + The index along the second dimension. + The index along the third dimension. + The index along the fourth dimension. + The value to set. + + + Fetches an element from a 4D array. You can also use the syntax 'array.[index1,index2,index3,index4]' + The input array. + The index along the first dimension. + The index along the second dimension. + The index along the third dimension. + The index along the fourth dimension. + The value at the given index. + + + Creates an array where the entries are initially the "default" value. + The length of the first dimension. + The length of the second dimension. + The length of the third dimension. + The length of the fourth dimension. + The created array. + + + Returns the length of an array in the fourth dimension. + The input array. + The length of the array in the fourth dimension. + + + Returns the length of an array in the third dimension. + The input array. + The length of the array in the third dimension. + + + Returns the length of an array in the second dimension. + The input array. + The length of the array in the second dimension. + + + Returns the length of an array in the first dimension + The input array. + The length of the array in the first dimension. + + + Creates an array given the dimensions and a generator function to compute the elements. + The length of the first dimension. + The length of the second dimension. + The length of the third dimension. + The length of the fourth dimension. + The function to create an initial value at each index in the array. + The created array. + + + Creates an array whose elements are all initially the given value + The length of the first dimension. + The length of the second dimension. + The length of the third dimension. + The length of the fourth dimension. + The initial value for each element of the array. + The created array. + + + Basic operations on rank 4 arrays. + + + Combines three arrays into an array of pairs. The three arrays must have equal lengths, otherwise an ArgumentException is + raised. + The first input array. + The second input array. + The third input array. + Thrown when the input arrays differ in length. + The array of tupled elements. + + + Combines the two arrays into an array of pairs. The two arrays must have equal lengths, otherwise an ArgumentException is + raised. + The first input array. + The second input array. + Thrown when the input arrays differ in length. + The array of tupled elements. + + + Splits an array of triples into three arrays. + The input array. + The tuple of three arrays. + + + Splits an array of pairs into two arrays. + The input array. + The two arrays. + + + Returns the index of the first element in the array + that satisfies the given predicate. + The function to test the input elements. + The input array. + The index of the first element that satisfies the predicate, or None. + + + Returns the first element for which the given function returns true. + Return None if no such element exists. + The function to test the input elements. + The input array. + The first element that satisfies the predicate, or None. + + + Views the given array as a sequence. + The input array. + The sequence of array elements. + + + Builds a list from the given array. + The input array. + The list of array elements. + + + Returns the sum of the results generated by applying the function to each element of the array. + The function to transform the array elements into the type to be summed. + The input array. + The resulting sum. + + + Returns the sum of the elements in the array. + The input array. + The resulting sum. + + + Sorts the elements of an array by mutating the array in-place, using the given comparison function. + Elements are compared using Operators.compare. + The input array. + + + Sorts the elements of an array by mutating the array in-place, using the given comparison function as the order. + The function to compare pairs of array elements. + The input array. + + + Sorts the elements of an array by mutating the array in-place, using the given projection for the keys. + Elements are compared using Operators.compare. + + This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. + For a stable sort, consider using Seq.sort. + The function to transform array elements into the type that is compared. + The input array. + + + Sorts the elements of an array, using the given comparison function as the order, returning a new array. + + This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. + For a stable sort, consider using Seq.sort. + The function to compare pairs of array elements. + The input array. + The sorted array. + + + Sorts the elements of an array, using the given projection for the keys and returning a new array. + Elements are compared using Operators.compare. + + This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. + For a stable sort, consider using Seq.sort. + The function to transform array elements into the type that is compared. + The input array. + The sorted array. + + + Sorts the elements of an array, returning a new array. Elements are compared using Operators.compare. + + This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. + For a stable sort, consider using Seq.sort. + The input array. + The sorted array. + + + Builds a new array that contains the given subrange specified by + starting index and length. + The input array. + The index of the first element of the sub array. + The length of the sub array. + The created sub array. + + + Sets an element of an array. + The input array. + The input index. + The input value. + + + Like foldBack, but return both the intermediary and final results. + The function to update the state given the input elements. + The input array. + The initial state. + The array of state values. + + + Like fold, but return the intermediary and final results. + The function to update the state given the input elements. + The initial state. + The input array. + The array of state values. + + + Returns a new array with the elements in reverse order. + The input array. + The reversed array. + + + Applies a function to each element of the array, threading an accumulator argument + through the computation. If the input function is f and the elements are i0...iN + then computes f i0 (...(f iN-1 iN)). + Raises ArgumentException if the array has size zero. + The function to reduce a pair of elements to a single element. + The input array. + Thrown when the input array is empty. + The final result of the reductions. + + + Applies a function to each element of the array, threading an accumulator argument + through the computation. If the input function is f and the elements are i0...iN + then computes f (... (f i0 i1)...) iN. + Raises ArgumentException if the array has size zero. + The function to reduce a pair of elements to a single element. + The input array. + Thrown when the input array is empty. + The final result of the redcutions. + + + Returns an array with all elements permuted according to the + specified permutation. + The function that maps input indices to output indices. + The input array. + The output array. + + + Splits the collection into two collections, containing the + elements for which the given predicate returns "true" and "false" + respectively. + The function to test the input elements. + The input array. + A pair of arrays. The first containing the elements the predicate evaluated to true, + and the second containing those evaluated to false. + + + Builds a new array from the given enumerable object. + The input sequence. + The array of elements from the sequence. + + + Builds an array from the given list. + The input list. + The array of elements from the list. + + + Returns the lowest of all elements of the array, compared via Operators.min on the function result. + + Throws ArgumentException for empty arrays. + The function to transform the elements into a type supporting comparison. + The input array. + Thrown when the input array is empty. + The minimum element. + + + Returns the lowest of all elements of the array, compared via Operators.min. + + Throws ArgumentException for empty arrays + The input array. + Thrown when the input array is empty. + The minimum element. + + + Returns the greatest of all elements of the array, compared via Operators.max on the function result. + + Throws ArgumentException for empty arrays. + The function to transform the elements into a type supporting comparison. + The input array. + Thrown when the input array is empty. + The maximum element. + + + Returns the greatest of all elements of the array, compared via Operators.max on the function result. + + Throws ArgumentException for empty arrays. + The input array. + Thrown when the input array is empty. + The maximum element. + + + Builds a new array whose elements are the results of applying the given function + to each of the elements of the array. The integer index passed to the + function indicates the index of element being transformed. + The function to transform elements and their indices. + The input array. + The array of transformed elements. + + + Builds a new collection whose elements are the results of applying the given function + to the corresponding elements of the two collections pairwise, also passing the index of + the elements. The two input arrays must have the same lengths, otherwise an ArgumentException is + raised. + The function to transform pairs of input elements and their indices. + The first input array. + The second input array. + Thrown when the input arrays differ in length. + The array of transformed elements. + + + Builds a new collection whose elements are the results of applying the given function + to the corresponding elements of the two collections pairwise. The two input + arrays must have the same lengths, otherwise an ArgumentException is + raised. + The function to transform the pairs of the input elements. + The first input array. + The second input array. + Thrown when the input arrays differ in length. + The array of transformed elements. + + + Builds a new array whose elements are the results of applying the given function + to each of the elements of the array. + The function to transform elements of the array. + The input array. + The array of transformed elements. + + + Returns the length of an array. You can also use property arr.Length. + The input array. + The length of the array. + + + Applies the given function to pair of elements drawn from matching indices in two arrays, + also passing the index of the elements. The two arrays must have the same lengths, + otherwise an ArgumentException is raised. + The function to apply to each index and pair of elements. + The first input array. + The second input array. + Thrown when the input arrays differ in length. + + + Applies the given function to each element of the array. The integer passed to the + function indicates the index of element. + The function to apply to each index and element. + The input array. + + + Applies the given function to pair of elements drawn from matching indices in two arrays. The + two arrays must have the same lengths, otherwise an ArgumentException is + raised. + The function to apply. + The first input array. + The second input array. + Thrown when the input arrays differ in length. + + + Applies the given function to each element of the array. + The function to apply. + The input array. + + + Returns true if the given array is empty, otherwise false. + The input array. + True if the array is empty. + + + Creates an array where the entries are initially the default value Unchecked.defaultof<'T>. + The length of the array to create. + The created array. + + + Creates an array given the dimension and a generator function to compute the elements. + The number of elements to initialize. + The function to generate the initial values for each index. + The created array. + + + Gets an element from an array. + The input array. + The input index. + The value of the array at the given index. + + + Apply a function to pairs of elements drawn from the two collections, right-to-left, + threading an accumulator argument through the computation. The two input + arrays must have the same lengths, otherwise an ArgumentException is + raised. + The function to update the state given the input elements. + The first input array. + The second input array. + The initial state. + Thrown when the input arrays differ in length. + The final state. + + + Applies a function to pairs of elements drawn from the two collections, + left-to-right, threading an accumulator argument + through the computation. The two input + arrays must have the same lengths, otherwise an ArgumentException is + raised. + The function to update the state given the input elements. + The initial state. + The first input array. + The second input array. + Thrown when the input arrays differ in length. + The final state. + + + Applies a function to each element of the array, threading an accumulator argument + through the computation. If the input function is f and the elements are i0...iN then computes + f i0 (...(f iN s)) + The function to update the state given the input elements. + The input array. + The initial state. + The final state. + + + Applies a function to each element of the collection, threading an accumulator argument + through the computation. If the input function is f and the elements are i0...iN then computes + f (... (f s i0)...) iN + The function to update the state given the input elements. + The initial state. + The input array. + The final state. + + + Tests if all corresponding elements of the array satisfy the given predicate pairwise. + + The predicate is applied to matching elements in the two collections up to the lesser of the + two lengths of the collections. If any application returns false then the overall result is + false and no further elements are tested. Otherwise, if one collection is longer + than the other then the ArgumentException exception is raised. + Otherwise, true is returned. + The function to test the input elements. + The first input array. + The second input array. + Thrown when the input arrays differ in length. + True if all of the array elements satisfy the predicate. + + + Tests if all elements of the array satisfy the given predicate. + + The predicate is applied to the elements of the input collection. If any application + returns false then the overall result is false and no further elements are tested. + Otherwise, true is returned. + The function to test the input elements. + The input array. + True if all of the array elements satisfy the predicate. + + + Returns the index of the first element in the array + that satisfies the given predicate. Raise KeyNotFoundException if + none of the elements satisy the predicate. + The function to test the input elements. + The input array. + Thrown if predicate + never returns true. + The index of the first element in the array that satisfies the given predicate. + + + Returns the first element for which the given function returns 'true'. + Raise KeyNotFoundException if no such element exists. + The function to test the input elements. + The input array. + Thrown if predicate + never returns true. + The first element for which predicate returns true. + + + 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 array. + An array containing the elements for which the given predicate returns true. + + + Tests if any pair of corresponding elements of the arrays satisfies the given predicate. + + The predicate is applied to matching elements in the two collections up to the lesser of the + two lengths of the collections. If any application returns true then the overall result is + true and no further elements are tested. Otherwise, if one collections is longer + than the other then the ArgumentException exception is raised. + Otherwise, false is returned. + The function to test the input elements. + The first input array. + The second input array. + True if any result from predicate is true. + + + Tests if any element of the array satisfies the given predicate. + + The predicate is applied to the elements of the input array. If any application + returns true then the overall result is true and no further elements are tested. + Otherwise, false is returned. + The function to test the input elements. + The input array. + True if any result from predicate is true. + + + Returns an empty array of the given type. + + + 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) + The function to generate options from the elements. + The input array. + The array of results. + + + Applies the given function to successive elements, returning the first + result where function returns Some(x) for some x. If the function + never returns Some(x) then KeyNotFoundException is raised. + The function to generate options from the elements. + The input array. + Thrown if every result from + chooser is None. + The first result. + + + Fills a range of elements of the array with the given value. + The target array. + The index of the first element to set. + The number of elements to set. + The value to set. + + + Applies the given function to successive elements, returning the first + result where function returns Some(x) for some x. If the function + never returns Some(x) then None is returned. + The function to transform the array elements into options. + The input array. + The first transformed element that is Some(x). + + + Creates an array whose elements are all initially the given value. + The length of the array to create. + The value for the elements. + The created array. + + + Builds a new array that contains the elements of the given array. + The input array. + A copy of the input array. + + + Builds a new array that contains the elements of each of the given sequence of arrays. + The input sequence of arrays. + The concatenation of the sequence of input arrays. + + + For each element of the array, applies the given function. Concatenates all the results and return the combined array. + The function to create sub-arrays from the input array elements. + The input array. + The concatenation of the sub-arrays. + + + Reads a range of elements from the first array and write them into the second. + The source array. + The starting index of the source array. + The target array. + The starting index of the target array. + The number of elements to copy. + + + Returns the average of the elements generated by applying the function to each element of the array. + The function to transform the array elements before averaging. + The input array. + Thrown when array is empty. + The computed average. + + + Returns the average of the elements in the array. + The input array. + Thrown when array is empty. + The average of the elements in the array. + + + Builds a new array that contains the elements of the first array followed by the elements of the second array. + The first input array. + The second input array. + The resulting array. + + + Split the collection into two collections, containing the + elements for which the given predicate returns "true" and "false" + respectively + + Performs the operation in parallel using System.Threading.Parallel.For. + The order in which the given function is applied to indicies is not specified. + The function to test the input elements. + The input array. + 'T[] * 'T[] + + + Create an array given the dimension and a generator function to compute the elements. + + Performs the operation in parallel using System.Threading.Parallel.For. + The order in which the given function is applied to indicies is not specified. + + + 'T[] + + + Apply the given function to each element of the array. The integer passed to the + function indicates the index of element. + + Performs the operation in parallel using System.Threading.Parallel.For. + The order in which the given function is applied to elements of the input array is not specified. + + The input array. + + + Apply the given function to each element of the array. + + Performs the operation in parallel using System.Threading.Parallel.For. + The order in which the given function is applied to elements of the input array is not specified. + + The input array. + + + Build a new array whose elements are the results of applying the given function + to each of the elements of the array. The integer index passed to the + function indicates the index of element being transformed. + + Performs the operation in parallel using System.Threading.Parallel.For. + The order in which the given function is applied to elements of the input array is not specified. + + The input array. + 'U[] + + + Build a new array whose elements are the results of applying the given function + to each of the elements of the array. + + Performs the operation in parallel using System.Threading.Parallel.For. + The order in which the given function is applied to elements of the input array is not specified. + + The input array. + 'U[] + + + For each element of the array, apply the given function. Concatenate all the results and return the combined array. + + Performs the operation in parallel using System.Threading.Parallel.For. + The order in which the given function is applied to elements of the input array is not specified. + + The input array. + 'U[] + + + Apply the given function to each element of the array. Return + the array comprised of the results "x" for each element where + the function returns Some(x). + + Performs the operation in parallel using System.Threading.Parallel.For. + The order in which the given function is applied to elements of the input array is not specified. + The function to generate options from the elements. + The input array. + 'U[] + + + Provides parallel operations on arrays + + + Basic operations on arrays. + + + Compare using the given comparer function. + A function to compare two values. + An object implementing IComparer using the supplied comparer. + + + Structural comparison. Compare using Operators.compare. + + + Common notions of comparison identity used with sorted data structures. + + + Hash using the given hashing and equality functions. + A function to generate a hash code from a value. + A function to test equality of two values. + An object implementing IEqualityComparer using the supplied functions. + + + Physical hashing (hash on reference identity of objects, and the contents of value types). + Hash using LanguagePrimitives.PhysicalEquality and LanguagePrimitives.PhysicalHash, + That is, for value types use GetHashCode and Object.Equals (if no other optimization available), + and for reference types use System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode and + reference equality. + + + + + + Structural hashing. Hash using Operators.(=) and Operators.hash. + + + Common notions of value identity used with hash tables. + + + Combines the three lists into a list of triples. The lists must have equal lengths. + The first input list. + The second input list. + The third input list. + A single list containing triples of matching elements from the input lists. + + + Combines the two lists into a list of pairs. The two lists must have equal lengths. + The first input list. + The second input list. + A single list containing pairs of matching elements from the input lists. + + + Splits a list of triples into three lists. + The input list. + Three lists of split elements. + + + Splits a list of pairs into two lists. + The input list. + Two lists of split elements. + + + Returns the index of the first element in the list + that satisfies the given predicate. + Return None if no such element exists. + The function to test the input elements. + The input list. + The index of the first element for which the predicate returns true, or None if + every element evaluates to false. + + + Returns the first element for which the given function returns true.. + Return None if no such element exists. + The function to test the input elements. + The input list. + The first element for which the predicate returns true, or None if + every element evaluates to false. + + + Applies the given function to successive elements, returning Some(x) the first + result where function returns Some(x) for some x. If no such element + exists then return None. + The function to generate options from the elements. + The input list. + The first resulting value or None. + + + Views the given list as a sequence. + The input list. + The sequence of elements in the list. + + + Builds an array from the given list. + The input list. + The array containing the elements of the list. + + + + + + Returns the sum of the results generated by applying the function to each element of the list. + The function to transform the list elements into the type to be summed. + The input list. + The resulting sum. + + + Returns the sum of the elements in the list. + The input list. + The resulting sum. + + + Sorts the given list using Operators.compare. + + This is a stable sort, i.e. the original order of equal elements is preserved. + The input list. + The sorted list. + + + Sorts the given list using keys given by the given projection. Keys are compared using Operators.compare. + + This is a stable sort, i.e. the original order of equal elements is preserved. + The function to transform the list elements into the type to be compared. + The input list. + The sorted list. + + + Sorts the given list using the given comparison function. + + This is a stable sort, i.e. the original order of equal elements is preserved. + The function to compare the list elements. + The input list. + The sorted list. + + + Like foldBack, but returns both the intermediary and final results + The function to update the state given the input elements. + The input list. + The initial state. + The list of states. + + + Applies a function to each element of the collection, threading an accumulator argument + through the computation. Take the second argument, and apply the function to it + and the first element of the list. Then feed this result into the function along + with the second element and so on. Returns the list of intermediate results and the final result. + The function to update the state given the input elements. + The initial state. + The input list. + The list of states. + + + Returns a new list with the elements in reverse order. + The input list. + The reversed list. + + + Creates a list by calling the given generator on each index. + The number of elements to replicate. + The value to replicate + The generated list. + + + Applies a function to each element of the collection, threading an accumulator argument + through the computation. If the input function is f and the elements are i0...iN then computes + f i0 (...(f iN-1 iN)). + + Raises System.ArgumentException if list is empty + The function to reduce two list elements to a single element. + The input list. + Thrown when the list is empty. + The final reduced value. + + + Apply a function to each element of the collection, threading an accumulator argument + through the computation. Apply the function to the first two elements of the list. + Then feed this result into the function along with the third element and so on. + Return the final result. If the input function is f and the elements are i0...iN then computes + f (... (f i0 i1) i2 ...) iN. + + Raises System.ArgumentException if list is empty + The function to reduce two list elements to a single element. + The input list. + Thrown when the list is empty. + The final reduced value. + + + Returns a list with all elements permuted according to the + specified permutation. + The function to map input indices to output indices. + The input list. + The permutated list. + + + Applies the given function to successive elements, returning the first + result where function returns Some(x) for some x. If no such + element exists then raise System.Collections.Generic.KeyNotFoundException + The function to generate options from the elements. + The input list. + Thrown when the list is empty. + The first resulting value. + + + Splits the collection into two collections, containing the + elements for which the given predicate returns true and false + respectively. + The function to test the input elements. + The input list. + A list containing the elements for which the predicate evaluated to false and a list + containing the elements for which the predicate evaluated to true. + + + Builds a new list from the given enumerable object. + The input sequence. + The list of elements from the sequence. + + + Builds a list from the given array. + The input array. + The list of elements from the array. + + + Indexes into the list. The first element has index 0. + The input list. + The index to retrieve. + The value at the given index. + + + Returns the lowest of all elements of the list, compared via Operators.min on the function result + + Raises System.ArgumentException if list is empty. + The function to transform list elements into the type to be compared. + The input list. + Thrown when the list is empty. + The minimum value. + + + Returns the lowest of all elements of the list, compared via Operators.min. + + Raises System.ArgumentException if list is empty + The input list. + Thrown when the list is empty. + The minimum value. + + + Returns the greatest of all elements of the list, compared via Operators.max on the function result. + + Raises System.ArgumentException if list is empty. + The function to transform the list elements into the type to be compared. + The input list. + Thrown when the list is empty. + The maximum element. + + + Return the greatest of all elements of the list, compared via Operators.max. + + Raises System.ArgumentException if list is empty + The input list. + Thrown when the list is empty. + The maximum element. + + + Like mapi, but mapping corresponding elements from two lists of equal length. + The function to transform pairs of elements from the two lists and their index. + The first input list. + The second input list. + The list of transformed elements. + + + Builds a new collection whose elements are the results of applying the given function + to each of the elements of the collection. The integer index passed to the + function indicates the index (from 0) of element being transformed. + The function to transform elements and their indices. + The input list. + The list of transformed elements. + + + Builds a new collection whose elements are the results of applying the given function + to the corresponding elements of the three collections simultaneously. + The function to transform triples of elements from the input lists. + The first input list. + The second input list. + The third input list. + The list of transformed elements. + + + Builds a new collection whose elements are the results of applying the given function + to the corresponding elements of the two collections pairwise. + The function to transform pairs of elements from the input lists. + The first input list. + The second input list. + The list of transformed elements. + + + 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. + + + Returns the length of the list. + The input list. + The length of the list. + + + Applies the given function to two collections simultaneously. The + collections must have identical size. The integer passed to the + function indicates the index of element. + The function to apply to a pair of elements from the input lists along with their index. + The first input list. + The second input list. + + + Applies the given function to each element of the collection. The integer passed to the + function indicates the index of element. + The function to apply to the elements of the list along with their index. + The input list. + + + Applies the given function to two collections simultaneously. The + collections must have identical size. + The function to apply to pairs of elements from the input lists. + The first input list. + The second input list. + + + Applies the given function to each element of the collection. + The function to apply to elements from the input list. + The input list. + + + Returns true if the list contains no elements, false otherwise. + The input list. + True if the list is empty. + + + Creates a list by calling the given generator on each index. + The length of the list to generate. + The function to generate an element from an index. + The list of generated elements. + + + Returns the first element of the list. + + Raises System.ArgumentException if list is empty + The input list. + Thrown when the list is empty. + The first element of the list. + + + Tests if all corresponding elements of the collection satisfy the given predicate pairwise. + + The predicate is applied to matching elements in the two collections up to the lesser of the + two lengths of the collections. If any application returns false then the overall result is + false and no further elements are tested. Otherwise, if one collection is longer + than the other then the System.ArgumentException exception is raised. + Otherwise, true is returned. + The function to test the input elements. + The first input list. + The second input list. + Thrown when the input lists differ in length. + True if all of the pairs of elements satisfy the predicate. + + + Tests if all elements of the collection satisfy the given predicate. + + The predicate is applied to the elements of the input list. If any application + returns false then the overall result is false and no further elements are tested. + Otherwise, true is returned. + The function to test the input elements. + The input list. + True if all of the elements satisfy the predicate. + + + Applies a function to corresponding elements of two collections, threading an accumulator argument + through the computation. The collections must have identical sizes. + If the input function is f and the elements are i0...iN and j0...jN + then computes f i0 j0 (...(f iN jN s)). + The function to update the state given the input elements. + The first input list. + The second input list. + The initial state. + The final state value. + + + Applies a function to each element of the collection, threading an accumulator argument + through the computation. If the input function is f and the elements are i0...iN then + computes f i0 (...(f iN s)). + The function to update the state given the input elements. + The input list. + The initial state. + The final state value. + + + Applies a function to corresponding elements of two collections, threading an accumulator argument + through the computation. The collections must have identical sizes. + If the input function is f and the elements are i0...iN and j0...jN + then computes f (... (f s i0 j0)...) iN jN. + The function to update the state given the input elements. + The initial state. + The first input list. + The second input list. + The final state value. + + + Applies a function to each element of the collection, threading an accumulator argument + through the computation. Take the second argument, and apply the function to it + and the first element of the list. Then feed this result into the function along + with the second element and so on. Return the final result. + If the input function is f and the elements are i0...iN then + computes f (... (f s i0) i1 ...) iN. + The function to update the state given the input elements. + The initial state. + The input list. + The final state value. + + + 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. + + + Returns the index of the first element in the list + that satisfies the given predicate. + Raises KeyNotFoundException if no such element exists. + The function to test the input elements. + The input list. + Thrown if the predicate evaluates to false for all the + elements of the list. + The index of the first element that satisfies the predicate. + + + Returns the first element for which the given function returns true. + Raises KeyNotFoundException if no such element exists. + The function to test the input elements. + The input list. + Thrown if the predicate evaluates to false for + all the elements of the list. + The first element that satisfies the predicate. + + + Tests if any pair of corresponding elements of the lists satisfies the given predicate. + + The predicate is applied to matching elements in the two collections up to the lesser of the + two lengths of the collections. If any application returns true then the overall result is + true and no further elements are tested. Otherwise, if one collections is longer + than the other then the System.ArgumentException exception is raised. + Otherwise, false is returned. + The function to test the input elements. + The first input list. + The second input list. + Thrown when the input lists differ in length. + True if any pair of elements satisfy the predicate. + + + Tests if any element of the list satisfies the given predicate. + + The predicate is applied to the elements of the input list. If any application + returns true then the overall result is true and no further elements are tested. + Otherwise, false is returned. + The function to test the input elements. + The input list. + True if any element satisfies the predicate. + + + Returns an empty list of the given type. + + + Returns a new list that contains the elements of each the lists in order. + The input sequence of lists. + The resulting concatenated list. + + + For each element of the list, applies the given function. Concatenates all the results and return 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. + + + Applies the given function to each element of the list. Returns + the list comprised of the results x for each element where + the function returns Some(x) + The function to generate options from the elements. + The input list. + The list comprising the values selected from the chooser function. + + + Returns the average of the elements generated by applying the function to each element of the list. + + Raises System.ArgumentException if list is empty. + The function to transform the list elements into the type to be averaged. + The input list. + Thrown when the list is empty. + The resulting average. + + + Returns the average of the elements in the list. + + Raises System.ArgumentException if list is empty. + The input list. + Thrown when the list is empty. + The resulting average. + + + Returns a new list that contains the elements of the first list + followed by elements of the second. + The first input list. + The second input list. + The resulting list. + + + Basic operations on lists. + + + Returns the key of the first mapping in the collection that satisfies the given predicate. + Returns 'None' if no such element exists. + The function to test the input elements. + The input map. + The first key for which the predicate returns true or None if the predicate evaluates to false for each key/value pair. + + + Evaluates the function on each mapping in the collection. Returns the key for the first mapping + where the function returns 'true'. Raise KeyNotFoundException if no such element exists. + The function to test the input elements. + The input map. + Thrown if the key does not exist in the map. + The first key for which the predicate evaluates true. + + + Lookup an element in the map, returning a Some value if the element is in the domain + of the map and None if not. + The input key. + The input map. + The found Some value or None. + + + Removes an element from the domain of the map. No exception is raised if the element is not present. + The input key. + The input map. + The resulting map. + + + Builds two new maps, one containing the bindings for which the given predicate returns 'true', + and the other the remaining bindings. + The function to test the input elements. + The input map. + A pair of maps in which the first contains the elements for which the predicate returned true + and the second containing the elements for which the predicated returned false. + + + Tests if an element is in the domain of the map. + The input key. + The input map. + True if the map contains the key. + + + Builds a new collection whose elements are the results of applying the given function + to each of the elements of the collection. The key passed to the + function indicates the key of element being transformed. + The function to transform the key/value pairs. + The input map. + The resulting map of keys and transformed values. + + + Returns true if the given predicate returns true for all of the + bindings in the map. + The function to test the input elements. + The input map. + True if the predicate evaluates to true for all of the bindings in the map. + + + Builds a new map containing only the bindings for which the given predicate returns 'true'. + The function to test the key/value pairs. + The input map. + The filtered map. + + + Returns true if the given predicate returns true for one of the + bindings in the map. + The function to test the input elements. + The input map. + True if the predicate returns true for one of the key/value pairs. + + + Applies the given function to each binding in the dictionary + The function to apply to each key/value pair. + The input map. + + + Folds over the bindings in the map + The function to update the state given the input key/value pairs. + The initial state. + The input map. + The final state value. + + + Folds over the bindings in the map. + The function to update the state given the input key/value pairs. + The input map. + The initial state. + The final state value. + + + Searches the map looking for the first element where the given function returns a Some value + The function to generate options from the key/value pairs. + The input map. + The first result. + + + Searches the map looking for the first element where the given function returns a Some value. + The function to generate options from the key/value pairs. + The input map. + The first result. + + + 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. + + + The empty map. + + + Is the map empty? + The input map. + True if the map is empty. + + + Returns an array of all key-value pairs in the mapping. + The array will be ordered by the keys of the map. + The input map. + The array of key/value pairs. + + + Returns a list of all key-value pairs in the mapping. + The list will be ordered by the keys of the map. + The input map. + The list of key/value pairs. + + + Views the collection as an enumerable sequence of pairs. + The sequence will be ordered by the keys of the map. + The input map. + The sequence of key/value pairs. + + + Returns a new map made from the given bindings. + The input sequence of key/value pairs. + The resulting map. + + + Returns a new map made from the given bindings. + The input array of key/value pairs. + The resulting map. + + + Returns a new map made from the given bindings. + The input list of key/value pairs. + The resulting map. + + + Returns a new map with the binding added to the given map. + The input key. + The input value. + The input map. + The resulting map. + + + Functional programming operators related to the Map<_,_> type. + + + Combines the three sequences into a list of triples. The sequences need not have equal lengths: + when one sequence is exhausted any remaining elements in the other + sequences are ignored. + + The first input sequence. + The second input sequence. + The third input sequence. + + The result sequence. + + Thrown when any of the input sequences is null. + + + Combines the two sequences into a list of pairs. The two sequences need not have equal lengths: + when one sequence is exhausted any remaining elements in the other + sequence are ignored. + + The first input sequence. + The second input sequence. + + The result sequence. + + Thrown when either of the input sequences is null. + + + Returns a sequence that yields sliding windows of containing elements drawn from the input + sequence. Each window is returned as a fresh array. + + The number of elements in each window. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when the input sequence is empty. + + + Returns a sequence that contains the elements generated by the given computation. + The given initial state argument is passed to the element generator. + For each IEnumerator elements in the stream are generated on-demand by applying the element + generator, until a None value is returned by the element generator. Each call to the element + generator returns a new residual state. + + The stream will be recomputed each time an IEnumerator is requested and iterated for the Seq. + + The returned sequence may be passed between threads safely. However, + individual IEnumerator values generated from the returned sequence should not be accessed concurrently. + + A function that takes in the current state and returns an option tuple of the next + element of the sequence and the next state value. + The initial state value. + + The result sequence. + + + Returns a sequence that when enumerated returns at most N elements. + + The maximum number of items to enumerate. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Applies the given function to successive elements, returning the first + result where the function returns "Some(x)". + + A function that transforms items from the input sequence into options. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns the index of the first element in the sequence + that satisfies the given predicate. Return None if no such element exists. + + A function that evaluates to a Boolean when given an item in the sequence. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns the first element for which the given function returns true. + Return None if no such element exists. + + A function that evaluates to a Boolean when given an item in the sequence. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Builds a list from the given collection. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Builds an array from the given collection. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns a sequence that, when iterated, yields elements of the underlying sequence while the + given predicate returns true, and then returns no further elements. + + A function that evaluates to false when no more items should be returned. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns the first N elements of the sequence. + Throws InvalidOperationException + if the count exceeds the number of elements in the sequence. Seq.truncate + returns as many items as the sequence contains instead of throwing an exception. + + The number of items to take. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when the input sequence is empty. + Thrown when count exceeds the number of elements + in the sequence. + + + Returns the sum of the results generated by applying the function to each element of the sequence. + The generated elements are summed using the + operator and Zero property associated with the generated type. + + A function to transform items from the input sequence into the type that will be summed. + The input sequence. + + The result sequence. + + + Returns the sum of the elements in the sequence. + + The elements are summed using the + operator and Zero property associated with the generated type. + + The input sequence. + + The result sequence. + + + Applies a key-generating function to each element of a sequence and yield a sequence ordered + by keys. The keys are compared using generic comparison as implemented by Operators.compare. + + This function returns a sequence that digests the whole initial sequence as soon as + that sequence is iterated. As a result this function should not be used with + large or infinite sequences. The function makes no assumption on the ordering of the original + sequence. + + This is a stable sort, that is the original order of equal elements is preserved. + + A function to transform items of the input sequence into comparable keys. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Yields a sequence ordered by keys. + + This function returns a sequence that digests the whole initial sequence as soon as + that sequence is iterated. As a result this function should not be used with + large or infinite sequences. The function makes no assumption on the ordering of the original + sequence. + + This is a stable sort, that is the original order of equal elements is preserved. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns a sequence that, when iterated, skips elements of the underlying sequence while the + given predicate returns true, and then yields the remaining elements of the sequence. + + A function that evaluates an element of the sequence to a boolean value. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns a sequence that skips N elements of the underlying sequence and then yields the + remaining elements of the sequence. + + The number of items to skip. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when count exceeds the number of elements + in the sequence. + + + Returns a sequence that yields one item only. + + The input item. + + The result sequence. + + + Like fold, but computes on-demand and returns the sequence of intermediary and final results. + + A function that updates the state with each element from the sequence. + The initial state. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Applies a function to each element of the sequence, threading an accumulator argument + through the computation. Begin by applying the function to the first two elements. + Then feed this result into the function along with the third element and so on. + Return the final result. + + A function that takes in the current accumulated result and the next + element of the sequence to produce the next accumulated result. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when the input sequence is empty. + + + Builds a new sequence object that delegates to the given sequence object. This ensures + the original sequence cannot be rediscovered and mutated by a type cast. For example, + if given an array the returned sequence will return the elements of the array, but + you cannot cast the returned sequence object to an array. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Applies the given function to successive elements, returning the first + x where the function returns "Some(x)". + + A function to transform each item of the input sequence into an option of the output type. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when every item of the sequence + evaluates to None when the given function is applied. + + + Returns a sequence of each element in the input sequence and its predecessor, with the + exception of the first element which is only returned as the predecessor of the second element. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Views the given list as a sequence. + + The input list. + + The result sequence. + + + Views the given array as a sequence. + + The input array. + + The result sequence. + + Thrown when the input sequence is null. + + + Computes the nth element in the collection. + + The index of element to retrieve. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns the lowest of all elements of the sequence, compared via Operators.min on the function result. + + A function to transform items from the input sequence into comparable keys. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when the input sequence is empty. + + + Returns the lowest of all elements of the sequence, compared via Operators.min. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when the input sequence is empty. + + + Returns the greatest of all elements of the sequence, compared via Operators.max on the function result. + + A function to transform items from the input sequence into comparable keys. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when the input sequence is empty. + + + Returns the greatest of all elements of the sequence, compared via Operators.max + + The input sequence. + + Thrown when the input sequence is null. + Thrown when the input sequence is empty. + + The result sequence. + + + Builds a new collection whose elements are the results of applying the given function + to each of the elements of the collection. The integer index passed to the + function indicates the index (from 0) of element being transformed. + + A function to transform items from the input sequence that also supplies the current index. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Builds a new collection whose elements are the results of applying the given function + to the corresponding pairs of elements from the two sequences. If one input sequence is shorter than + the other then the remaining elements of the longer sequence are ignored. + + A function to transform pairs of items from the input sequences. + The first input sequence. + The second input sequence. + + The result sequence. + + Thrown when either of the input sequences is null. + + + 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 MoveNext method on enumerators retrieved from the + object. + + The returned sequence may be passed between threads safely. However, + individual IEnumerator values generated from the returned sequence should not be accessed concurrently. + + A function to transform items from the input sequence. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns the length of the sequence + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Applies the given function to two collections simultaneously. If one sequence is shorter than + the other then the remaining elements of the longer sequence are ignored. + + A function to apply to each pair of elements from the input sequences. + The first input sequence. + The second input sequence. + + The result sequence. + + Thrown when either of the input sequences is null. + + + Applies the given function to each element of the collection. The integer passed to the + function indicates the index of element. + + A function to apply to each element of the sequence that can also access the current index. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Applies the given function to each element of the collection. + + A function to apply to each element of the sequence. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Generates a new sequence which, when iterated, will return successive + elements by calling the given function. The results of calling the function + will not be saved, that is the function will be reapplied as necessary to + regenerate the elements. The function is passed the index of the item being + generated. + + The returned sequence may be passed between threads safely. However, + individual IEnumerator values generated from the returned sequence should not be accessed concurrently. + Iteration can continue up to Int32.MaxValue. + + A function that generates an item in the sequence from a given index. + + The result sequence. + + + Generates a new sequence which, when iterated, will return successive + elements by calling the given function, up to the given count. The results of calling the function + will not be saved, that is the function will be reapplied as necessary to + regenerate the elements. The function is passed the index of the item being + generated. + + The returned sequence may be passed between threads safely. However, + individual IEnumerator values generated from the returned sequence should not be accessed concurrently. + + The maximum number of items to generate for the sequence. + A function that generates an item in the sequence from a given index. + + The result sequence. + + Thrown when count is negative. + + + Returns true if the sequence contains no elements, false otherwise. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns the first element of the sequence. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when the input does not have any elements. + + + Applies a key-generating function to each element of a sequence and yields a sequence of + unique keys. Each unique key has also contains a sequence of all elements that match + to this key. + + This function returns a sequence that digests the whole initial sequence as soon as + that sequence is iterated. As a result this function should not be used with + large or infinite sequences. The function makes no assumption on the ordering of the original + sequence. + + A function that transforms an element of the sequence into a comparable key. + The input sequence. + + The result sequence. + + + Tests the all pairs of elements drawn from the two sequences satisfy the + given predicate. If one sequence is shorter than + the other then the remaining elements of the longer sequence are ignored. + + A function to test pairs of elements from the input sequences. + The first input sequence. + The second input sequence. + + The result sequence. + + Thrown when either of the input sequences is null. + + + Tests if all elements of the sequence satisfy the given predicate. + + The predicate is applied to the elements of the input sequence. If any application + returns false then the overall result is false and no further elements are tested. + Otherwise, true is returned. + + A function to test an element of the input sequence. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Applies a function to each element of the collection, threading an accumulator argument + through the computation. If the input function is f and the elements are i0...iN + then computes f (... (f s i0)...) iN + + A function that updates the state with each element from the sequence. + The initial state. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns the index of the first element for which the given function returns true. + + A function to test whether the index of a particular element should be returned. + The input sequence. + + The result sequence. + + Thrown if no element returns true when + evaluated by the predicate + Thrown when the input sequence is null + + + Returns the first element for which the given function returns true. + + A function to test whether an item in the sequence should be returned. + The input sequence. + + The result sequence. + + Thrown if no element returns true when + evaluated by the predicate + Thrown when the input sequence is null + + + Returns a new collection containing only the elements of the collection + for which the given predicate returns "true". + + 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. + + A function to test whether each item in the input sequence should be included in the output. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Tests if any pair of corresponding elements of the input sequences satisfies the given predicate. + + The predicate is applied to matching elements in the two sequences up to the lesser of the + two lengths of the collections. If any application returns true then the overall result is + true and no further elements are tested. Otherwise, false is returned. If one sequence is shorter than + the other then the remaining elements of the longer sequence are ignored. + + A function to test each pair of items from the input sequences. + The first input sequence. + The second input sequence. + + The result sequence. + + Thrown when either of the two input sequences is null. + + + Tests if any element of the sequence satisfies the given predicate. + + The predicate is applied to the elements of the input sequence. If any application + returns true then the overall result is true and no further elements are tested. + Otherwise, false is returned. + + A function to test each item of the input sequence. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Creates an empty sequence. + + The result sequence. + + + Returns a sequence that contains no duplicate entries according to the + generic hash and equality comparisons on the keys returned by the given key-generating function. + If an element occurs multiple times in the sequence then the later occurrences are discarded. + + A function transforming the sequence items into comparable keys. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + 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. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns a sequence that is built from the given delayed specification of a + sequence. + + The input function is evaluated each time an IEnumerator for the sequence + is requested. + + The generating function for the sequence. + + + Applies a key-generating function to each element of a sequence and return a sequence yielding unique + keys and their number of occurrences in the original sequence. + + Note that this function returns a sequence that digests the whole initial sequence as soon as + that sequence is iterated. As a result this function should not be used with + large or infinite sequences. The function makes no assumption on the ordering of the original + sequence. + + A function transforming each item of input sequence into a key to be + compared against the others. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Combines the given enumeration-of-enumerations as a single concatenated + enumeration. + + The returned sequence may be passed between threads safely. However, + individual IEnumerator values generated from the returned sequence should not be accessed concurrently. + + The input enumeration-of-enumerations. + + The result sequence. + + Thrown when the input sequence is null. + + + Compares two sequences using the given comparison function, element by element. + Returns the first non-zero result from the comparison function. If the end of a sequence + is reached it returns a -1 if the first sequence is shorter and a 1 if the second sequence + is shorter. + + A function that takes an element from each sequence and returns an int. + If it evaluates to a non-zero value iteration is stopped and that value is returned. + The first input sequence. + The second input sequence. + + The result sequence. + + Thrown when either of the input sequences + is null. + + + Applies the given function to each element of the sequence and concatenates all the + results. + + Remember sequence is lazy, effects are delayed until it is enumerated. + + A function to transform elements of the input sequence into the sequences + that will then be concatenated. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + 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). + + The returned sequence may be passed between threads safely. However, + individual IEnumerator values generated from the returned sequence should not + be accessed concurrently. + + A function to transform items of type T into options of type U. + The input sequence of type T. + + The result sequence. + + Thrown when the input sequence is null. + + + Wraps a loosely-typed System.Collections sequence as a typed sequence. + + The use of this function usually requires a type annotation. + An incorrect type annotation may result in runtime type + errors. + Individual IEnumerator values generated from the returned sequence should not be accessed concurrently. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns a sequence that corresponds to a cached version of the input sequence. + This result sequence will have the same elements as the input sequence. The result + can be enumerated multiple times. The input sequence will be enumerated at most + once and only as far as is necessary. Caching a sequence is typically useful when repeatedly + evaluating items in the original sequence is computationally expensive or if + iterating the sequence causes side-effects that the user does not want to be + repeated multiple times. + + Enumeration of the result sequence is thread safe in the sense that multiple independent IEnumerator + values may be used simultaneously from different threads (accesses to + the internal lookaside table are thread safe). Each individual IEnumerator + is not typically thread safe and should not be accessed concurrently. + + Once enumeration of the input sequence has started, + it's enumerator will be kept live by this object until the enumeration has completed. + At that point, the enumerator will be disposed. + + The enumerator may be disposed and underlying cache storage released by + converting the returned sequence object to type IDisposable, and calling the Dispose method + on this object. The sequence object may then be re-enumerated and a fresh enumerator will + be used. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + + + Returns the average of the results generated by applying the function to each element + of the sequence. + + The elements are averaged using the + operator, DivideByInt method and Zero property + associated with the generated type. + + A function applied to transform each element of the sequence. + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when the input sequence has zero elements. + + + Returns the average of the elements in the sequence. + + The elements are averaged using the + operator, DivideByInt method and Zero property + associated with the element type. + + The input sequence. + + The result sequence. + + Thrown when the input sequence is null. + Thrown when the input sequence has zero elements. + + + Wraps the two given enumerations as a single concatenated + enumeration. + + The returned sequence may be passed between threads safely. However, + individual IEnumerator values generated from the returned sequence should not be accessed + concurrently. + + The first sequence. + The second sequence. + + The result sequence. + + Thrown when either of the two provided sequences is + null. + + + Basic operations on IEnumerables. + + + Returns a new set with the elements of the second set removed from the first. + The first input set. + The set whose elements will be removed from set1. + The set with the elements of set2 removed from set1. + + + Builds a new collection from the given enumerable object. + The input sequence. + The set containing elements. + + + Returns an ordered view of the collection as an enumerable object. + The input set. + An ordered sequence of the elements of set. + + + Builds an array that contains the elements of the set in order. + The input set. + An ordered array of the elements of set. + + + Builds a set that contains the same elements as the given array. + The input array. + A set containing the elements of array. + + + Builds a list that contains the elements of the set in order. + The input set. + An ordered list of the elements of 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. + + + Returns the highest element in the set according to the ordering being used for the set. + The input set. + The max value from the set. + + + Returns the lowest element in the set according to the ordering being used for the set. + The input set. + The min value from the set. + + + Returns a new set with the given element removed. No exception is raised if + the set doesn't contain the given element. + The element to remove. + The input set. + The input set with value removed. + + + Splits the set into two sets containing the elements for which the given predicate + returns true and false respectively. + The function to test set elements. + The input set. + A pair of sets with the first containing the elements for which predicate returns + true and the second containing the elements for which predicate returns false. + + + Applies the given function to each element of the set, in order according + to the comparison function. + The function to apply to each element. + The input set. + + + Returns "true" if the set is empty. + The input set. + True if set is empty. + + + Computes the union of a sequence of sets. + The sequence of sets to untion. + The union of the input sets. + + + Computes the union of the two sets. + The first input set. + The second input set. + The union of set1 and set2. + + + Computes the intersection of a sequence of sets. The sequence must be non-empty. + The sequence of sets to intersect. + The intersection of the input sets. + + + Computes the intersection of the two sets. + The first input set. + The second input set. + The intersection of set1 and set2. + + + Tests if all elements of the collection satisfy the given predicate. + If the input function is f and the elements are i0...iN and "j0...jN" + then computes p i0 && ... && p iN. + The function to test set elements. + The input set. + True if all elements of set satisfy predicate. + + + Applies the given accumulating function to all the elements of the set. + The accumulating function. + The input set. + The initial state. + The final state. + + + Applies the given accumulating function to all the elements of the set + The accumulating function. + The initial state. + The input set. + The final state. + + + Returns a new collection containing the results of applying the + given function to each element of the input set. + The function to transform elements of the input set. + The input set. + A set containing the transformed elements. + + + Returns a new collection containing only the elements of the collection + for which the given predicate returns true. + The function to test set elements. + The input set. + The set containing only the elements for which predicate returns true. + + + Tests if any element of the collection satisfies the given predicate. + If the input function is predicate and the elements are i0...iN + then computes p i0 or ... or p iN. + The function to test set elements. + The input set. + True if any element of set satisfies predicate. + + + Returns the number of elements in the set. Same as size. + The input set. + The number of elements in the set. + + + Evaluates to "true" if all elements of the second set are in the first, and at least + one element of the first is not in the second. + The potential superset. + The set to test against. + True if set1 is a proper superset of set2. + + + Evaluates to "true" if all elements of the second set are in the first. + The potential superset. + The set to test against. + True if set1 is a superset of set2. + + + Evaluates to "true" if all elements of the first set are in the second, and at least + one element of the second is not in the first. + The potential subset. + The set to test against. + True if set1 is a proper subset of set2. + + + Evaluates to "true" if all elements of the first set are in the second + The potential subset. + The set to test against. + True if set1 is a subset of set2. + + + 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. + + + Returns a new set with an element added to the set. No exception is raised if + the set already contains the given element. + The value to add. + The input set. + A new set containing value. + + + The set containing the given element. + The value for the set to contain. + The set containing value. + + + The empty set for the type 'T. + + + Functional programming operators related to the Set<_> type. + + + Gets the default cancellation token for executing asynchronous computations. + The default CancellationToken. + + + Creates an asynchronous computation that returns the CancellationToken governing the execution + of the computation. + In async { let! token = Async.CancellationToken ...} token can be used to initiate other + asynchronous operations that will cancel cooperatively with this workflow. + An asynchronous computation capable of retrieving the CancellationToken from a computation + expression. + + + Creates an asynchronous computation that executes computation. + If this computation is cancelled before it completes then the computation generated by + running compensation is executed. + The input asynchronous computation. + The function to be run if the computation is cancelled. + An asynchronous computation that runs the compensation if the input computation + is cancelled. + + + Creates an asynchronous computation that queues a work item that runs + its continuation. + A computation that generates a new work item in the thread pool. + + + Creates an asynchronous computation that creates a new thread and runs + its continuation in that thread. + A computation that will execute on a new thread. + + + Creates an asynchronous computation that runs + its continuation using syncContext.Post. If syncContext is null + then the asynchronous computation is equivalent to SwitchToThreadPool(). + The synchronization context to accept the posted computation. + An asynchronous computation that uses the syncContext context to execute. + + + Runs an asynchronous computation, starting immediately on the current operating system + thread. Call one of the three continuations when the operation completes. + If no cancellation token is provided then the default cancellation token + is used. + The asynchronous computation to execute. + The function called on success. + The function called on exception. + The function called on cancellation. + The CancellationToken to associate with the computation. + The default is used if this parameter is not provided. + + + Runs an asynchronous computation, starting immediately on the current operating system + thread. + If no cancellation token is provided then the default cancellation token is used. + The asynchronous computation to execute. + The CancellationToken to associate with the computation. + The default is used if this parameter is not provided. + + + + Creates an asynchronous computation which starts the given computation as a <c>System.Threading.Tasks.Task</c> + + + + Starts a child computation within an asynchronous workflow. + This allows multiple asynchronous computations to be executed simultaneously. + + This method should normally be used as the immediate + right-hand-side of a let! binding in an F# asynchronous workflow, that is, + + async { ... + let! completor1 = childComputation1 |> Async.StartChild + let! completor2 = childComputation2 |> Async.StartChild + ... + let! result1 = completor1 + let! result2 = completor2 + ... } + + When used in this way, each use of StartChild starts an instance of childComputation + and returns a completor object representing a computation to wait for the completion of the operation. + When executed, the completor awaits the completion of childComputation. + The child computation. + The timeout value in milliseconds. If one is not provided + then the default value of -1 corresponding to System.Threading.Timeout.Infinite. + A new computation that waits for the input computation to finish. + + + + Executes a computation in the thread pool. Returns a <c>System.Threading.Tasks.Task</c> that will be completed + in the corresponding state once the computation terminates (produces the result, throws exception or gets canceled) + + If no cancellation token is provided then the default cancellation token is used. + + + + Starts the asynchronous computation in the thread pool. Do not await its result. + + If no cancellation token is provided then the default cancellation token is used. + The computation to run asynchronously. + The cancellation token to be associated with the computation. + If one is not supplied, the default cancellation token is used. + + + Creates an asynchronous computation that will sleep for the given time. This is scheduled + using a System.Threading.Timer object. The operation will not block operating system threads + for the duration of the wait. + The number of milliseconds to sleep. + An asynchronous computation that will sleep for the given time. + Thrown when the due time is negative + and not infinite. + + + Runs the asynchronous computation and await its result. + + If an exception occurs in the asynchronous computation then an exception is re-raised by this + function. + + If no cancellation token is provided then the default cancellation token is used. + + The timeout parameter is given in milliseconds. A value of -1 is equivalent to + System.Threading.Timeout.Infinite. + The computation to run. + The amount of time in milliseconds to wait for the result of the + computation before raising a System.TimeoutException. If no value is provided + for timeout then a default of -1 is used to correspond to System.Threading.Timeout.Infinite. + The cancellation token to be associated with the computation. + If one is not supplied, the default cancellation token is used. + The result of the computation. + + + Creates an asynchronous computation that executes all the given asynchronous computations, + initially queueing each as work items and using a fork/join pattern. + + If all child computations succeed, an array of results is passed to the success continuation. + + If any child computation raises an exception, then the overall computation will trigger an + exception, and cancel the others. + + The overall computation will respond to cancellation while executing the child computations. + If cancelled, the computation will cancel any remaining child computations but will still wait + for the other child computations to complete. + A sequence of distinct computations to be parallelized. + A computation that returns an array of values from the sequence of input computations. + + + Generates a scoped, cooperative cancellation handler for use within an asynchronous workflow. + + For example, + async { use! holder = Async.OnCancel interruption ... } + generates an asynchronous computation where, if a cancellation happens any time during + the execution of the asynchronous computation in the scope of holder, then action + interruption is executed on the thread that is performing the cancellation. This can + be used to arrange for a computation to be asynchronously notified that a cancellation + has occurred, e.g. by setting a flag, or deregistering a pending I/O action. + The function that is executed on the thread performing the + cancellation. + An asynchronous computation that triggers the interruption if it is cancelled + before being disposed. + + + Creates an asynchronous computation that runs the given computation and ignores + its result. + The input computation. + A computation that is equivalent to the input computation, but disregards the result. + + + Creates an asynchronous computation that captures the current + success, exception and cancellation continuations. The callback must + eventually call exactly one of the given continuations. + The function that accepts the current success, exception, and cancellation + continuations. + An asynchronous computation that provides the callback with the current continuations. + + + Creates an asynchronous computation in terms of a Begin/End pair of actions in + the style used in CLI APIs. This overlaod should be used if the operation is + qualified by three arguments. For example, + Async.FromBeginEnd(arg1,arg2,arg3,ws.BeginGetWeather,ws.EndGetWeather) + When the computation is run, beginFunc is executed, with + a callback which represents the continuation of the computation. + When the callback is invoked, the overall result is fetched using endFunc. + + The computation will respond to cancellation while waiting for the completion + of the operation. If a cancellation occurs, and cancelAction is specified, then it is + executed, and the computation continues to wait for the completion of the operation. + + If cancelAction is not specified, then cancellation causes the computation + to stop immediately, and subsequent invocations of the callback are ignored. + The first argument for the operation. + The second argument for the operation. + The third argument for the operation. + The function initiating a traditional CLI asynchronous operation. + The function completing a traditional CLI asynchronous operation. + An optional function to be executed when a cancellation is requested. + An asynchronous computation wrapping the given Begin/End functions. + + + Creates an asynchronous computation in terms of a Begin/End pair of actions in + the style used in CLI APIs. This overlaod should be used if the operation is + qualified by two arguments. For example, + Async.FromBeginEnd(arg1,arg2,ws.BeginGetWeather,ws.EndGetWeather) + When the computation is run, beginFunc is executed, with + a callback which represents the continuation of the computation. + When the callback is invoked, the overall result is fetched using endFunc. + + The computation will respond to cancellation while waiting for the completion + of the operation. If a cancellation occurs, and cancelAction is specified, then it is + executed, and the computation continues to wait for the completion of the operation. + + If cancelAction is not specified, then cancellation causes the computation + to stop immediately, and subsequent invocations of the callback are ignored. + The first argument for the operation. + The second argument for the operation. + The function initiating a traditional CLI asynchronous operation. + The function completing a traditional CLI asynchronous operation. + An optional function to be executed when a cancellation is requested. + An asynchronous computation wrapping the given Begin/End functions. + + + Creates an asynchronous computation in terms of a Begin/End pair of actions in + the style used in CLI APIs. This overlaod should be used if the operation is + qualified by one argument. For example, + Async.FromBeginEnd(place,ws.BeginGetWeather,ws.EndGetWeather) + When the computation is run, beginFunc is executed, with + a callback which represents the continuation of the computation. + When the callback is invoked, the overall result is fetched using endFunc. + + The computation will respond to cancellation while waiting for the completion + of the operation. If a cancellation occurs, and cancelAction is specified, then it is + executed, and the computation continues to wait for the completion of the operation. + + If cancelAction is not specified, then cancellation causes the computation + to stop immediately, and subsequent invocations of the callback are ignored. + The argument for the operation. + The function initiating a traditional CLI asynchronous operation. + The function completing a traditional CLI asynchronous operation. + An optional function to be executed when a cancellation is requested. + An asynchronous computation wrapping the given Begin/End functions. + + + Creates an asynchronous computation in terms of a Begin/End pair of actions in + the style used in CLI APIs. For example, + Async.FromBeginEnd(ws.BeginGetWeather,ws.EndGetWeather) + When the computation is run, beginFunc is executed, with + a callback which represents the continuation of the computation. + When the callback is invoked, the overall result is fetched using endFunc. + + The computation will respond to cancellation while waiting for the completion + of the operation. If a cancellation occurs, and cancelAction is specified, then it is + executed, and the computation continues to wait for the completion of the operation. + + If cancelAction is not specified, then cancellation causes the computation + to stop immediately, and subsequent invocations of the callback are ignored. + The function initiating a traditional CLI asynchronous operation. + The function completing a traditional CLI asynchronous operation. + An optional function to be executed when a cancellation is requested. + An asynchronous computation wrapping the given Begin/End functions. + + + Creates an asynchronous computation that executes computation. + If this computation completes successfully then return Choice1Of2 with the returned + value. If this computation raises an exception before it completes then return Choice2Of2 + with the raised exception. + The input computation that returns the type T. + A computation that returns a choice of type T or exception. + + + Raises the cancellation condition for the most recent set of asynchronous computations started + without any specific CancellationToken. Replaces the global CancellationTokenSource with a new + global token source for any asynchronous computations created after this point without any + specific CancellationToken. + + + Creates an asynchronous computation that will wait on the given WaitHandle. + + The computation returns true if the handle indicated a result within the given timeout. + The WaitHandle that can be signalled. + The timeout value in milliseconds. If one is not provided + then the default value of -1 corresponding to System.Threading.Timeout.Infinite. + An asynchronous computation that waits on the given WaitHandle. + + + + Return an asynchronous computation that will wait for the given task to complete and return + its result. + + + + Creates an asynchronous computation that will wait on the IAsyncResult. + + The computation returns true if the handle indicated a result within the given timeout. + The IAsyncResult to wait on. + The timeout value in milliseconds. If one is not provided + then the default value of -1 corresponding to System.Threading.Timeout.Infinite. + An asynchronous computation that waits on the given IAsyncResult. + + + Creates an asynchronous computation that waits for a single invocation of a CLI + event by adding a handler to the event. Once the computation completes or is + cancelled, the handler is removed from the event. + + The computation will respond to cancellation while waiting for the event. If a + cancellation occurs, and cancelAction is specified, then it is executed, and + the computation continues to wait for the event. + + If cancelAction is not specified, then cancellation causes the computation + to cancel immediately. + The event to handle once. + An optional function to execute instead of cancelling when a + cancellation is issued. + An asynchronous computation that waits for the event to be invoked. + + + Creates three functions that can be used to implement the .NET Asynchronous + Programming Model (APM) for a given asynchronous computation. + + The functions should normally be published as members with prefix Begin, + End and Cancel, and can be used within a type definition as follows: + + let beginAction,endAction,cancelAction = Async.AsBeginEnd (fun arg -> computation) + member x.BeginSomeOperation(arg,callback,state:obj) = beginAction(arg,callback,state) + member x.EndSomeOperation(iar) = endAction(iar) + member x.CancelSomeOperation(iar) = cancelAction(iar) + + + If the asynchronous computation takes no arguments, then AsBeginEnd is used as follows: + + let beginAction,endAction,cancelAction = Async.AsBeginEnd (fun () -> computation) + member x.BeginSomeOperation(callback,state:obj) = beginAction((),callback,state) + member x.EndSomeOperation(iar) = endAction(iar) + member x.CancelSomeOperation(iar) = cancelAction(iar) + + + + If the asynchronous computation takes two arguments, then AsBeginEnd is used as follows: + + let beginAction,endAction,cancelAction = Async.AsBeginEnd (fun arg1 arg2 -> computation) + member x.BeginSomeOperation(arg1,arg2,callback,state:obj) = beginAction((),callback,state) + member x.EndSomeOperation(iar) = endAction(iar) + member x.CancelSomeOperation(iar) = cancelAction(iar) + + + In each case, the resulting API will be familiar to programmers in other CLI languages and + is a useful way to publish asynchronous computations in CLI components. + A function generating the asynchronous computation to split into the traditional + .NET Asynchronous Programming Model. + A tuple of the begin, end, and cancel members. + + + This static class holds members for creating and manipulating asynchronous computations. + + + Creates an asynchronous computation that just returns (). + + A cancellation check is performed when the computation is executed. + + The existence of this method permits the use of empty else branches in the + async { ... } computation expression syntax. + An asynchronous computation that returns (). + + + Creates an asynchronous computation that runs computation repeatedly + until guard() becomes false. + + A cancellation check is performed whenever the computation is executed. + + The existence of this method permits the use of while in the + async { ... } computation expression syntax. + The function to determine when to stop executing computation. + The function to be executed. Equivalent to the body + of a while expression. + An asynchronous computation that behaves similarly to a while loop when run. + + + Creates an asynchronous computation that runs binder(resource). + The action resource.Dispose() is executed as this computation yields its result + or if the asynchronous computation exits by an exception or by cancellation. + + A cancellation check is performed when the computation is executed. + + The existence of this method permits the use of use and use! in the + async { ... } computation expression syntax. + The resource to be used and disposed. + The function that takes the resource and returns an asynchronous + computation. + An asynchronous computation that binds and eventually disposes resource. + + + Creates an asynchronous computation that runs computation and returns its result. + If an exception happens then catchHandler(exn) is called and the resulting computation executed instead. + + A cancellation check is performed when the computation is executed. + + The existence of this method permits the use of try/with in the + async { ... } computation expression syntax. + The input computation. + The function to run when computation throws an exception. + An asynchronous computation that executes computation and calls catchHandler if an + exception is thrown. + + + Creates an asynchronous computation that runs computation. The action compensation is executed + after computation completes, whether computation exits normally or by an exception. If compensation raises an exception itself + the original exception is discarded and the new exception becomes the overall result of the computation. + + A cancellation check is performed when the computation is executed. + + The existence of this method permits the use of try/finally in the + async { ... } computation expression syntax. + The input computation. + The action to be run after computation completes or raises an + exception (including cancellation). + An asynchronous computation that executes computation and compensation aftewards or + when an exception is raised. + + + Delegates to the input computation. + + The existence of this method permits the use of return! in the + async { ... } computation expression syntax. + The input computation. + The input computation. + + + Creates an asynchronous computation that returns the result v. + + A cancellation check is performed when the computation is executed. + + The existence of this method permits the use of return in the + async { ... } computation expression syntax. + The value to return from the computation. + An asynchronous computation that returns value when executed. + + + Creates an asynchronous computation that enumerates the sequence seq + on demand and runs body for each element. + + A cancellation check is performed on each iteration of the loop. + + The existence of this method permits the use of for in the + async { ... } computation expression syntax. + The sequence to enumerate. + A function to take an item from the sequence and create + an asynchronous computation. Can be seen as the body of the for expression. + An asynchronous computation that will enumerate the sequence and run body + for each element. + + + Creates an asynchronous computation that runs generator. + + A cancellation check is performed when the computation is executed. + The function to run. + An asynchronous computation that runs generator. + + + Creates an asynchronous computation that first runs computation1 + and then runs computation2, returning the result of computation2. + + A cancellation check is performed when the computation is executed. + + The existence of this method permits the use of expression sequencing in the + async { ... } computation expression syntax. + The first part of the sequenced computation. + The second part of the sequenced computation. + An asynchronous computation that runs both of the computations sequentially. + + + Creates an asynchronous computation that runs computation, and when + computation generates a result T, runs binder res. + + A cancellation check is performed when the computation is executed. + + The existence of this method permits the use of let! in the + async { ... } computation expression syntax. + The computation to provide an unbound result. + The function to bind the result of computation. + An asynchronous computation that performs a monadic bind on the result + of computation. + + + + Generate an object used to build asynchronous computations using F# computation expressions. The value + 'async' is a pre-defined instance of this type. + + A cancellation check is performed when the computation is executed. + + + + The type of the async operator, used to build workflows for asynchronous computations. + + + Sends a reply to a PostAndReply message. + The value to send. + + + A handle to a capability to reply to a PostAndReply message. + + + A compositional asynchronous computation, which, when run, will eventually produce a value + of type T, or else raises an exception. + + Asynchronous computations are normally specified using an F# computation expression. + + When run, asynchronous computations have two modes: as a work item (executing synchronous + code), or as a wait item (waiting for an event or I/O completion). + + When run, asynchronous computations can be governed by CancellationToken. This can usually + be specified when the async computation is started. The associated CancellationTokenSource + may be used to cancel the asynchronous computation. Asynchronous computations built using + computation expressions can check the cancellation condition regularly. Synchronous + computations within an asynchronous computation do not automatically check this condition. + + + Publishes the event as a first class event value. + + + Triggers the event using the given parameters. + The parameters for the event. + + + Creates an event object suitable for implementing an arbitrary type of delegate. + The event object. + + + Event implementations for an arbitrary type of delegate. + + + Publishes an observation as a first class value. + + + Triggers an observation using the given parameters. + The event parameters. + + + Creates an observable object. + The created event. + + + Event implementations for the IEvent<_> type. + + + Publishes the event as a first class event value. + + + Triggers the event using the given sender object and parameters. The sender object may be null. + The object triggering the event. + The parameters for the event. + + + Creates an event object suitable for delegate types following the standard .NET Framework convention of a first 'sender' argument. + The created event. + + + Event implementations for a delegate types following the standard .NET Framework convention of a first 'sender' argument. + + + + + + A delegate type associated with the F# event type IEvent<_> + The object that fired the event. + The event arguments. + + + Remove a listener delegate from an event listener store. + The delegate to be removed from the event listener store. + + + Connect a handler delegate object to the event. A handler can + be later removed using RemoveHandler. The listener will + be invoked when the event is fired. + A delegate to be invoked when the event is fired. + + + First class event values for arbitrary delegate types. + + F# gives special status to member properties compatible with type IDelegateEvent and + tagged with the CLIEventAttribute. In this case the F# compiler generates approriate + CLI metadata to make the member appear to other CLI languages as a CLI event. + + + First-class listening points (i.e. objects that permit you to register a callback + activated when the event is triggered). + + + First class event values for CLI events conforming to CLI Framework standards. + + + The type of delayed computations. + + Use the values in the Lazy module to manipulate + values of this type, and the notation lazy expr to create values + of type . + + + Raises a timeout exception if a message not received in this amount of time. By default + no timeout is used. + + + Occurs when the execution of the agent results in an exception. + + + Occurs when the execution of the agent results in an exception. + + + Raises a timeout exception if a message not received in this amount of time. By default + no timeout is used. + + + Returns the number of unprocessed messages in the message queue of the agent. + + + Occurs when the execution of the agent results in an exception. + + + Scans for a message by looking through messages in arrival order until scanner + returns a Some value. Other messages remain in the queue. + + This method is for use within the body of the agent. For each agent, at most + one concurrent reader may be active, so no more than one concurrent call to + Receive, TryReceive, Scan and/or TryScan may be active. + The function to return None if the message is to be skipped + or Some if the message is to be processed and removed from the queue. + An optional timeout in milliseconds. Defaults to -1 which corresponds + to System.Threading.Timeout.Infinite. + An asynchronous computation that scanner built off the read message. + + + Waits for a message. This will consume the first message in arrival order. + + This method is for use within the body of the agent. + + Returns None if a timeout is given and the timeout is exceeded. + + This method is for use within the body of the agent. For each agent, at most + one concurrent reader may be active, so no more than one concurrent call to + Receive, TryReceive, Scan and/or TryScan may be active. + An optional timeout in milliseconds. Defaults to -1 which + corresponds to System.Threading.Timeout.Infinite. + An asynchronous computation that returns the received message or + None if the timeout is exceeded. + + + Like PostAndReply, but returns None if no reply within the timeout period. + The function to incorporate the AsyncReplyChannel into + the message to be sent. + An optional timeout parameter (in milliseconds) to wait for a reply message. + Defaults to -1 which corresponds to System.Threading.Timeout.Infinite. + The reply from the agent or None if the timeout expires. + + + Starts the agent. + + + Creates and starts an agent. The body function is used to generate the asynchronous + computation executed by the agent. + The function to produce an asynchronous computation that will be executed + as the read loop for the MailboxProcessor when Start is called. + An optional cancellation token for the body. + Defaults to Async.DefaultCancellationToken. + The created MailboxProcessor. + + + Scans for a message by looking through messages in arrival order until scanner + returns a Some value. Other messages remain in the queue. + + Returns None if a timeout is given and the timeout is exceeded. + + This method is for use within the body of the agent. For each agent, at most + one concurrent reader may be active, so no more than one concurrent call to + Receive, TryReceive, Scan and/or TryScan may be active. + The function to return None if the message is to be skipped + or Some if the message is to be processed and removed from the queue. + An optional timeout in milliseconds. Defaults to -1 which corresponds + to System.Threading.Timeout.Infinite. + An asynchronous computation that scanner built off the read message. + Thrown when the timeout is exceeded. + + + Waits for a message. This will consume the first message in arrival order. + + This method is for use within the body of the agent. + + This method is for use within the body of the agent. For each agent, at most + one concurrent reader may be active, so no more than one concurrent call to + Receive, TryReceive, Scan and/or TryScan may be active. + An optional timeout in milliseconds. Defaults to -1 which corresponds + to System.Threading.Timeout.Infinite. + An asynchronous computation that returns the received message. + Thrown when the timeout is exceeded. + + + Like AsyncPostAndReply, but returns None if no reply within the timeout period. + The function to incorporate the AsyncReplyChannel into + the message to be sent. + An optional timeout parameter (in milliseconds) to wait for a reply message. + Defaults to -1 which corresponds to System.Threading.Timeout.Infinite. + An asynchronous computation that will return the reply or None if the timeout expires. + + + Posts a message to an agent and await a reply on the channel, synchronously. + + The message is generated by applying buildMessage to a new reply channel + to be incorporated into the message. The receiving agent must process this + message and invoke the Reply method on this reply channel precisely once. + The function to incorporate the AsyncReplyChannel into + the message to be sent. + An optional timeout parameter (in milliseconds) to wait for a reply message. + Defaults to -1 which corresponds to System.Threading.Timeout.Infinite. + The reply from the agent. + + + Posts a message to an agent and await a reply on the channel, asynchronously. + + The message is generated by applying buildMessage to a new reply channel + to be incorporated into the message. The receiving agent must process this + message and invoke the Reply method on this reply channel precisely once. + The function to incorporate the AsyncReplyChannel into + the message to be sent. + An optional timeout parameter (in milliseconds) to wait for a reply message. + Defaults to -1 which corresponds to System.Threading.Timeout.Infinite. + An asychronous computation that will wait for the reply from the agent. + + + Posts a message to the message queue of the MailboxProcessor, asynchronously. + The message to post. + + + Creates an agent. The body function is used to generate the asynchronous + computation executed by the agent. This function is not executed until + Start is called. + The function to produce an asynchronous computation that will be executed + as the read loop for the MailboxProcessor when Start is called. + An optional cancellation token for the body. + Defaults to Async.DefaultCancellationToken. + The created MailboxProcessor. + + + A message-processing agent which executes an asynchronous computation. + + The agent encapsulates a message queue that supports multiple-writers and + a single reader agent. Writers send messages to the agent by using the Post + method and its variations. + + The agent may wait for messages using the Receive or TryReceive methods or + scan through all available messages using the Scan or TryScan method. + + + + + + Connects a listener function to the observable. The listener will + be invoked for each observation. The listener can be removed by + calling Dispose on the returned IDisposable object. + The function to be called for each observation. + An object that will remove the listener if disposed. + + + Permanently connects a listener function to the observable. The listener will + be invoked for each observation. + The function to be called for each observation. + + + Returns an asynchronous computation that will write the given bytes to the stream. + The buffer to write from. + An optional offset as a number of bytes in the stream. + An optional number of bytes to write to the stream. + An asynchronous computation that will write the given bytes to the stream. + Thrown when the sum of offset and count is longer than + the buffer length. + Thrown when offset or count is negative. + + + Returns an asynchronous computation that will read the given number of bytes from the stream. + The number of bytes to read. + An asynchronous computation that returns the read byte[] when run. + + + Returns an asynchronous computation that will read from the stream into the given buffer. + The buffer to read into. + An optional offset as a number of bytes in the stream. + An optional number of bytes to read from the stream. + An asynchronous computation that will read from the stream into the given buffer. + Thrown when the sum of offset and count is longer than + the buffer length. + Thrown when offset or count is negative. + + + A module of extension members providing asynchronous operations for some basic CLI types related to concurrency and I/O. + + + Returns a new event that triggers on the second and subsequent triggerings of the input event. + The Nth triggering of the input event passes the arguments from the N-1th and Nth triggering as + a pair. The argument passed to the N-1th triggering is held in hidden internal state until the + Nth triggering occurs. + The input event. + An event that triggers on pairs of consecutive values passed from the source event. + + + Runs the given function each time the given event is triggered. + The function to call when the event is triggered. + The input event. + + + Returns a new event consisting of the results of applying the given accumulating function + to successive values triggered on the input event. An item of internal state + records the current value of the state parameter. The internal state is not locked during the + execution of the accumulation function, so care should be taken that the + input IEvent not triggered by multiple threads simultaneously. + The function to update the state with each event value. + The initial state. + The input event. + An event that fires on the updated state values. + + + Returns a new event which fires on a selection of messages from the original event. + The selection function takes an original message to an optional new message. + The function to select and transform event values to pass on. + The input event. + An event that fires only when the chooser returns Some. + + + Returns a new event that listens to the original event and triggers the + first resulting event if the application of the function to the event arguments + returned a Choice1Of2, and the second event if it returns a Choice2Of2. + The function to transform event values into one of two types. + The input event. + A tuple of events. The first fires whenever splitter evaluates to Choice1of1 and + the second fires whenever splitter evaluates to Choice2of2. + + + Returns a new event that listens to the original event and triggers the + first resulting event if the application of the predicate to the event arguments + returned true, and the second event if it returned false. + The function to determine which output event to trigger. + The input event. + A tuple of events. The first is triggered when the predicate evaluates to true + and the second when the predicate evaluates to false. + + + Returns a new event that listens to the original event and triggers the resulting + event only when the argument to the event passes the given function. + The function to determine which triggers from the event to propagate. + The input event. + An event that only passes values that pass the predicate. + + + Returns a new event that passes values transformed by the given function. + The function to transform event values. + The input event. + An event that passes the transformed values. + + + Fires the output event when either of the input events fire. + The first input event. + The second input event. + An event that fires when either of the input events fire. + + + + + + Forces the execution of this value and return its result. Same as Value. Mutual exclusion is used to + prevent other threads also computing the value. + The value of the Lazy object. + + + Creates a lazy computation that evaluates to the given value when forced. + The input value. + The created Lazy object. + + + Creates a lazy computation that evaluates to the result of the given function when forced. + The function to provide the value when needed. + The created Lazy object. + + + Extensions related to Lazy values. + + + Returns a new observable that triggers on the second and subsequent triggerings of the input observable. + The Nth triggering of the input observable passes the arguments from the N-1th and Nth triggering as + a pair. The argument passed to the N-1th triggering is held in hidden internal state until the + Nth triggering occurs. + + For each observer, the registered intermediate observing object is not thread safe. + That is, observations arising from the source must not be triggered concurrently + on different threads. + The input Observable. + An Observable that triggers on successive pairs of observations from the input Observable. + + + Creates an observer which subscribes to the given observable and which calls + the given function for each observation. + The function to be called on each observation. + The input Observable. + An object that will remove the callback if disposed. + + + Creates an observer which permanently subscribes to the given observable and which calls + the given function for each observation. + The function to be called on each observation. + The input Observable. + + + Returns an observable which, for each observer, allocates an item of state + and applies the given accumulating function to successive values arising from + the input. The returned object will trigger observations for each computed + state value, excluding the initial value. The returned object propagates + all errors arising from the source and completes when the source completes. + + For each observer, the registered intermediate observing object is not thread safe. + That is, observations arising from the source must not be triggered concurrently + on different threads. + The function to update the state with each observation. + The initial state. + The input Observable. + An Observable that triggers on the updated state values. + + + Returns an observable which chooses a projection of observations from the source + using the given function. The returned object will trigger observations x + for which the splitter returns Some x. The returned object also propagates + all errors arising from the source and completes when the source completes. + The function that returns Some for observations to be propagated + and None for observations to ignore. + The input Observable. + An Observable that only propagates some of the observations from the source. + + + Returns two observables which split the observations of the source by the + given function. The first will trigger observations x for which the + splitter returns Choice1Of2 x. The second will trigger observations + y for which the splitter returns Choice2Of2 y The splitter is + executed once for each subscribed observer. Both also propagate error + observations arising from the source and each completes when the source + completes. + The function that takes an observation an transforms + it into one of the two output Choice types. + The input Observable. + A tuple of Observables. The first triggers when splitter returns Choice1of2 + and the second triggers when splitter returns Choice2of2. + + + Returns two observables which partition the observations of the source by + the given function. The first will trigger observations for those values + for which the predicate returns true. The second will trigger observations + for those values where the predicate returns false. The predicate is + executed once for each subscribed observer. Both also propagate all error + observations arising from the source and each completes when the source + completes. + The function to determine which output Observable will trigger + a particular observation. + The input Observable. + A tuple of Observables. The first triggers when the predicate returns true, and + the second triggers when the predicate returns false. + + + Returns an observable which filters the observations of the source + by the given function. The observable will see only those observations + for which the predicate returns true. The predicate is executed once for + each subscribed observer. The returned object also propagates error + observations arising from the source and completes when the source completes. + The function to apply to observations to determine if it should + be kept. + The input Observable. + An Observable that filters observations based on filter. + + + Returns an observable which transforms the observations of the source by the + given function. The transformation function is executed once for each + subscribed observer. The returned object also propagates error observations + arising from the source and completes when the source completes. + The function applied to observations from the source. + The input Observable. + An Observable of the type specified by mapping. + + + Returns an observable for the merged observations from the sources. + The returned object propagates success and error values arising + from either source and completes when both the sources have completed. + + For each observer, the registered intermediate observing object is not + thread safe. That is, observations arising from the sources must not + be triggered concurrently on different threads. + The first Observable. + The second Observable. + An Observable that propagates information from both sources. + + + Basic operations on first class event and other observable objects. + + + Returns an asynchronous computation that, when run, will wait for the download of the given URI. + The URI to retrieve. + An asynchronous computation that will wait for the download of the URI. + + + Returns an asynchronous computation that, when run, will wait for a response to the given WebRequest. + An asynchronous computation that waits for response to the WebRequest. + + + A module of extension members providing asynchronous operations for some basic Web operations. + + + Creates an instance of the attribute + AbstractClassAttribute + + + Adding this attribute to class definition makes it abstract, which means it need not + implement all its methods. Instances of abstract classes may not be constructed directly. + + + Creates an instance of the attribute + AllowNullLiteralAttribute + + + Adding this attribute to a type lets the 'null' literal be used for the type + within F# code. This attribute may only be added to F#-defined class or + interface types. + + + Indicates the namespace or module to be automatically opened when an assembly is referenced + or an enclosing module opened. + + + Creates an attribute used to mark a namespace or module path to be 'automatically opened' when an assembly is referenced + The namespace or module to be automatically opened when an assembly is referenced + or an enclosing module opened. + AutoOpenAttribute + + + Creates an attribute used to mark a module as 'automatically opened' when the enclosing namespace is opened + AutoOpenAttribute + + + This attribute is used for two purposes. When applied to an assembly, it must be given a string + argument, and this argument must indicate a valid module or namespace in that assembly. Source + code files compiled with a reference to this assembly are processed in an environment + where the given path is automatically oepned. + + When applied to a module within an assembly, then the attribute must not be given any arguments. + When the enclosing namespace is opened in user source code, the module is also implicitly opened. + + + The value of the attribute, indicating whether the type is automatically marked serializable or not + + + Creates an instance of the attribute + Indicates whether the type should be serializable by default. + AutoSerializableAttribute + + + Adding this attribute to a type with value 'false' disables the behaviour where F# makes the + type Serializable by default. + + + Creates an instance of the attribute + CLIEventAttribute + + + Adding this attribute to a property with event type causes it to be compiled with as a CLI + metadata event, through a syntactic translation to a pair of 'add_EventName' and + 'remove_EventName' methods. + + + Choice 2 of 2 choices + + + Choice 1 of 2 choices + + + Helper types for active patterns with 2 choices. + + + Choice 3 of 3 choices + + + Choice 2 of 3 choices + + + Choice 1 of 3 choices + + + Helper types for active patterns with 3 choices. + + + Choice 4 of 4 choices + + + Choice 3 of 4 choices + + + Choice 2 of 4 choices + + + Choice 1 of 4 choices + + + Helper types for active patterns with 4 choices. + + + Choice 5 of 5 choices + + + Choice 4 of 5 choices + + + Choice 3 of 5 choices + + + Choice 2 of 5 choices + + + Choice 1 of 5 choices + + + Helper types for active patterns with 5 choices. + + + Choice 6 of 6 choices + + + Choice 5 of 6 choices + + + Choice 4 of 6 choices + + + Choice 3 of 6 choices + + + Choice 2 of 6 choices + + + Choice 1 of 6 choices + + + Helper types for active patterns with 6 choices. + + + Choice 7 of 7 choices + + + Choice 6 of 7 choices + + + Choice 5 of 7 choices + + + Choice 4 of 7 choices + + + Choice 3 of 7 choices + + + Choice 2 of 7 choices + + + Choice 1 of 7 choices + + + Helper types for active patterns with 7 choices. + + + Creates an instance of the attribute + ClassAttribute + + + Adding this attribute to a type causes it to be represented using a CLI class. + + + Creates an instance of the attribute + ComparisonConditionalOnAttribute + + + This attribute is used to indicate a generic container type satisfies the F# 'comparison' + constraint only if a generic argument also satisfies this constraint. For example, adding + this attribute to parameter 'T on a type definition C<'T> means that a type C<X> only supports + comparison if the type X also supports comparison and all other conditions for C<X> to support + comparison are also met. The type C<'T> can still be used with other type arguments, but a type such + as C<(int -> int)> will not support comparison because the type (int -> int) is an F# function type + and does not support comparison. + + This attribute will be ignored if it is used on the generic parameters of functions or methods. + + + Indicates the number of arguments in each argument group + + + Creates an instance of the attribute + Indicates the number of arguments in each argument group. + CompilationArgumentCountsAttribute + + + This attribute is generated automatically by the F# compiler to tag functions and members + that accept a partial application of some of their arguments and return a residual function + + + Indicates the variant number of the entity, if any, in a linear sequence of elements with F# source code + + + Indicates the relationship between the compiled entity and F# source code + + + Indicates the sequence number of the entity, if any, in a linear sequence of elements with F# source code + + + Creates an instance of the attribute + Indicates the type of source construct. + CompilationMappingAttribute + + + Creates an instance of the attribute + Indicates the type of source construct. + CompilationMappingAttribute + + + Creates an instance of the attribute + Indicates the type of source construct. + CompilationMappingAttribute + + + This attribute is inserted automatically by the F# compiler to tag types + and methods in the generated CLI code with flags indicating the correspondence + with original source constructs. It is used by the functions in the + Microsoft.FSharp.Reflection namespace to reverse-map compiled constructs to + their original forms. It is not intended for use from user code. + + + Indicates one or more adjustments to the compiled representation of an F# type or member + + + Creates an instance of the attribute + Indicates adjustments to the compiled representation of the type or member. + CompilationRepresentationAttribute + + + This attribute is used to adjust the runtime representation for a type. + For example, it may be used to note that the null representation + may be used for a type. This affects how some constructs are compiled. + + + Compile a property as a CLI event. + + + Permit the use of null as a representation for nullary discriminators in a discriminated union. + + + append 'Module' to the end of a module whose name clashes with a type name in the same namespace. + + + Compile a member as 'instance' even if null is used as a representation for this type. + + + Compile an instance member as 'static' . + + + No special compilation representation. + + + + + + Indicates one or more adjustments to the compiled representation of an F# type or member. + + + Indicates the name of the entity in F# source code + + + Creates an instance of the attribute + The name of the method in source. + CompilationSourceNameAttribute + + + This attribute is inserted automatically by the F# compiler to tag + methods which are given the 'CompiledName' attribute. It is not intended + for use from user code. + + + The name of the value as it appears in compiled code + + + Creates an instance of the attribute + The name to use in compiled code. + CompiledNameAttribute + + + Adding this attribute to a value or function definition in an F# module changes the name used + for the value in compiled CLI code. + + + Indicates if the construct should always be hidden in an editing environment. + + + Indicates if the message should indicate a compiler error. Error numbers less than + 10000 are considered reserved for use by the F# compiler and libraries. + + + Indicates the number associated with the message. + + + Indicates the warning message to be emitted when F# source code uses this construct + + + Indicates if the construct should always be hidden in an editing environment. + + + Indicates if the message should indicate a compiler error. Error numbers less than + 10000 are considered reserved for use by the F# compiler and libraries. + + + Creates an instance of the attribute. + + + Indicates that a message should be emitted when F# source code uses this construct. + + + Creates an instance of the attribute + CustomComparisonAttribute + + + Adding this attribute to a type indicates it is a type with a user-defined implementation of comparison. + + + Creates an instance of the attribute + CustomEqualityAttribute + + + Adding this attribute to a type indicates it is a type with a user-defined implementation of equality. + + + The value of the attribute, indicating whether the type has a default augmentation or not + + + Creates an instance of the attribute + Indicates whether to generate helper members on the CLI class representing a discriminated + union. + DefaultAugmentationAttribute + + + Adding this attribute to a discriminated union with value false + turns off the generation of standard helper member tester, constructor + and accessor members for the generated CLI class for that type. + + + Indicates if a constraint is asserted that the field type supports 'null' + + + Creates an instance of the attribute + Indicates whether to assert that the field type supports null. + DefaultValueAttribute + + + Creates an instance of the attribute + DefaultValueAttribute + + + Adding this attribute to a field declaration means that the field is + not initialized. During type checking a constraint is asserted that the field type supports 'null'. + If the 'check' value is false then the constraint is not asserted. + + + Creates an instance of the attribute + EntryPointAttribute + + + Adding this attribute to a function indicates it is the entrypoint for an application. + If this absent is not speficied for an EXE then the initialization implicit in the + module bindings in the last file in the compilation sequence are used as the entrypoint. + + + Creates an instance of the attribute + EqualityConditionalOnAttribute + + + This attribute is used to indicate a generic container type satisfies the F# 'equality' + constraint only if a generic argument also satisfies this constraint. For example, adding + this attribute to parameter 'T on a type definition C<'T> means that a type C<X> only supports + equality if the type X also supports equality and all other conditions for C<X> to support + equality are also met. The type C<'T> can still be used with other type arguments, but a type such + as C<(int -> int)> will not support equality because the type (int -> int) is an F# function type + and does not support equality. + + This attribute will be ignored if it is used on the generic parameters of functions or methods. + + + Indicates the warning message to be emitted when F# source code uses this construct + + + Creates an instance of the attribute + The warning message to be emitted when code uses this construct. + ExperimentalAttribute + + + This attribute is used to tag values that are part of an experimental library + feature. + + + Convert an value of type System.Converter to a F# first class function value + The input System.Converter. + An F# function of the same type. + + + Convert an F# first class function value to a value of type System.Converter + The input function. + A System.Converter of the function type. + + + Convert an F# first class function value to a value of type System.Converter + The input function. + System.Converter<'T,'U> + + + Invoke an F# first class function value with two curried arguments. In some cases this + will result in a more efficient application than applying the arguments successively. + The input function. + The first arg. + The second arg. + The function result. + + + Invoke an F# first class function value with three curried arguments. In some cases this + will result in a more efficient application than applying the arguments successively. + The input function. + The first arg. + The second arg. + The third arg. + The function result. + + + Invoke an F# first class function value with four curried arguments. In some cases this + will result in a more efficient application than applying the arguments successively. + The input function. + The first arg. + The second arg. + The third arg. + The fourth arg. + The function result. + + + Invoke an F# first class function value with five curried arguments. In some cases this + will result in a more efficient application than applying the arguments successively. + The input function. + The first arg. + The second arg. + The third arg. + The fourth arg. + The fifth arg. + The function result. + + + Invoke an F# first class function value with one argument + + 'U + + + Convert an value of type System.Converter to a F# first class function value + The input System.Converter. + An F# function of the same type. + + + Construct an instance of an F# first class function value + The created F# function. + + + The CLI type used to represent F# function values. This type is not + typically used directly, though may be used from other CLI languages. + + + The release number of the F# version associated with the attribute + + + The minor version number of the F# version associated with the attribute + + + The major version number of the F# version associated with the attribute + + + Creates an instance of the attribute + The major version number. + The minor version number. + The release number. + FSharpInterfaceDataVersionAttribute + + + This attribute is added to generated assemblies to indicate the + version of the data schema used to encode additional F# + specific information in the resource attached to compiled F# libraries. + + + Specialize the type function at a given type + The specialized type. + + + Construct an instance of an F# first class type function value + FSharpTypeFunc + + + The CLI type used to represent F# first-class type function values. This type is for use + by compiled F# code. + + + Type of a formatting expression. + Function type generated by printf. + Type argument passed to %a formatters + Value generated by the overall printf action (e.g. sprint generates a string) + Value generated after post processing (e.g. failwithf generates a string internally then raises an exception) + + + Type of a formatting expression. + Function type generated by printf. + Type argument passed to %a formatters + Value generated by the overall printf action (e.g. sprint generates a string) + Value generated after post processing (e.g. failwithf generates a string internally then raises an exception) + Tuple of values generated by scan or match. + + + Convert the given Converter delegate object to an F# function value + The input Converter. + The F# function. + + + Convert the given Action delegate object to an F# function value + The input action. + The F# function. + + + A utility function to convert function values from tupled to curried form + The input tupled function. + The output curried function. + + + A utility function to convert function values from tupled to curried form + The input tupled function. + The output curried function. + + + A utility function to convert function values from tupled to curried form + The input tupled function. + The output curried function. + + + A utility function to convert function values from tupled to curried form + The input tupled function. + The output curried function. + + + Helper functions for converting F# first class function values to and from CLI representaions + of functions using delegates. + + + Creates an instance of the attribute + GeneralizableValueAttribute + + + Adding this attribute to a non-function value with generic parameters indicates that + uses of the construct can give rise to generic code through type inference. + + + Creates an instance of the attribute + InterfaceAttribute + + + Adding this attribute to a type causes it to be represented using a CLI interface. + + + Creates an instance of the attribute + LiteralAttribute + + + Adding this attribute to a value causes it to be compiled as a CLI constant literal. + + + Creates an instance of the attribute + MeasureAnnotatedAbbreviationAttribute + + + Adding this attribute to a type causes it to be interpreted as a refined type, currently limited to measure-parameterized types. + This may only be used under very limited conditions. + + + Creates an instance of the attribute + MeasureAttribute + + + Adding this attribute to a type causes it to be interpreted as a unit of measure. + This may only be used under very limited conditions. + + + Creates an instance of the attribute + NoComparisonAttribute + + + Adding this attribute to a type indicates it is a type where comparison is an abnormal operation. + This means that the type does not satisfy the F# 'comparison' constraint. Within the bounds of the + F# type system, this helps ensure that the F# generic comparison function is not instantiated directly + at this type. The attribute and checking does not constrain the use of comparison with base or child + types of this type. + + + Creates an instance of the attribute + NoDynamicInvocationAttribute + + + This attribute is used to tag values that may not be dynamically invoked at runtime. This is + typically added to inlined functions whose implementations include unverifiable code. It + causes the method body emitted for the inlined function to raise an exception if + dynamically invoked, rather than including the unverifiable code in the generated + assembly. + + + Creates an instance of the attribute + NoEqualityAttribute + + + Adding this attribute to a type indicates it is a type where equality is an abnormal operation. + This means that the type does not satisfy the F# 'equality' constraint. Within the bounds of the + F# type system, this helps ensure that the F# generic equality function is not instantiated directly + at this type. The attribute and checking does not constrain the use of comparison with base or child + types of this type. + + + The representation of "Value of type 'T" + The input value. + An option representing the value. + + + The representation of "No value" + + + Get the value of a 'Some' option. A NullReferenceException is raised if the option is 'None'. + + + Create an option value that is a 'None' value. + + + Return 'true' if the option is a 'Some' value. + + + Return 'true' if the option is a 'None' value. + + + Create an option value that is a 'Some' value. + The input value + An option representing the value. + + + The type of optional values. When used from other CLI languages the + empty option is the null value. + + Use the constructors Some and None to create values of this type. + Use the values in the Option module to manipulate values of this type, + or pattern match against the values directly. + + None values will appear as the value null to other CLI languages. + Instance methods on this type will appear as static methods to other CLI languages + due to the use of null as a value representation. + + + Creates an instance of the attribute + OptionalArgumentAttribute + + + This attribute is added automatically for all optional arguments. + + + The raw text of the format string. + + + Construct a format string + The input string. + The PrintfFormat containing the formatted result. + + + Type of a formatting expression. + Function type generated by printf. + Type argument passed to %a formatters + Value generated by the overall printf action (e.g. sprint generates a string) + Value generated after post processing (e.g. failwithf generates a string internally then raises an exception) + + + Construct a format string + The input string. + The created format string. + + + Type of a formatting expression. + Function type generated by printf. + Type argument passed to %a formatters + Value generated by the overall printf action (e.g. sprint generates a string) + Value generated after post processing (e.g. failwithf generates a string internally then raises an exception) + Tuple of values generated by scan or match. + + + + The current value of the reference cell + + + + The current value of the reference cell + + + The current value of the reference cell + + + The type of mutable references. Use the functions [:=] and [!] to get and + set values of this type. + + + Creates an instance of the attribute + ReferenceEqualityAttribute + + + Adding this attribute to a record or union type disables the automatic generation + of overrides for 'System.Object.Equals(obj)', 'System.Object.GetHashCode()' + and 'System.IComparable' for the type. The type will by default use reference equality. + + + Creates an instance of the attribute + ReflectedDefinitionAttribute + + + Adding this attribute to the let-binding for the definition of a top-level + value makes the quotation expression that implements the value available + for use at runtime. + + + Creates an instance of the attribute + RequireQualifiedAccessAttribute + + + This attribute is used to indicate that references to a the elements of a module, record or union + type require explicit qualified access. + + + Creates an instance of the attribute + RequiresExplicitTypeArgumentsAttribute + + + Adding this attribute to a type, value or member requires that + uses of the construct must explicitly instantiate any generic type parameters. + + + The value of the attribute, indicating whether the type is sealed or not. + + + Creates an instance of the attribute + Indicates whether the class is sealed. + SealedAttribute + + + Creates an instance of the attribute. + The created attribute. + + + Adding this attribute to class definition makes it sealed, which means it may not + be extended or implemented. + + + Indicates that the compiled entity had private or internal representation in F# source code. + + + The mask of values related to the kind of the compiled entity. + + + Indicates that the compiled entity is part of the representation of an F# value declaration. + + + Indicates that the compiled entity is part of the representation of an F# union case declaration. + + + Indicates that the compiled entity is part of the representation of an F# module declaration. + + + Indicates that the compiled entity is part of the representation of an F# closure. + + + Indicates that the compiled entity is part of the representation of an F# exception declaration. + + + Indicates that the compiled entity is part of the representation of an F# record or union case field declaration. + + + Indicates that the compiled entity is part of the representation of an F# class or other object type declaration. + + + Indicates that the compiled entity is part of the representation of an F# record type declaration. + + + Indicates that the compiled entity is part of the representation of an F# union type declaration. + + + Indicates that the compiled entity has no relationship to an element in F# source code. + + + + + + Indicates the relationship between a compiled entity in a CLI binary and an element in F# source code. + + + Creates an instance of the attribute + StructAttribute + + + Adding this attribute to a type causes it to be represented using a CLI struct. + + + Creates an instance of the attribute + StructuralComparisonAttribute + + + Adding this attribute to a record, union, exception, or struct type confirms the + automatic generation of implementations for 'System.IComparable' for the type. + + + Creates an instance of the attribute + StructuralEqualityAttribute + + + Adding this attribute to a record, union or struct type confirms the automatic + generation of overrides for 'System.Object.Equals(obj)' and + 'System.Object.GetHashCode()' for the type. + + + Indicates the text to display by default when objects of this type are displayed + using '%A' printf formatting patterns and other two-dimensional text-based display + layouts. + + + Creates an instance of the attribute + Indicates the text to display when using the '%A' printf formatting. + StructuredFormatDisplayAttribute + + + This attribute is used to mark how a type is displayed by default when using + '%A' printf formatting patterns and other two-dimensional text-based display layouts. + In this version of F# the only valid values are of the form PreText {PropertyName} PostText. + The property name indicates a property to evaluate and to display instead of the object itself. + + + The type 'unit', which has only one value "()". This value is special and + always uses the representation 'null'. + + + Creates an instance of the attribute + UnverifiableAttribute + + + This attribute is used to tag values whose use will result in the generation + of unverifiable code. These values are inevitably marked 'inline' to ensure that + the unverifiable constructs are not present in the actual code for the F# library, + but are rather copied to the source code of the caller. + + + Creates an instance of the attribute + VolatileFieldAttribute + + + Adding this attribute to an F# mutable binding causes the "volatile" + prefix to be used for all accesses to the field. + + + Four dimensional arrays, typically zero-based. Non-zero-based arrays + can be created using methods on the System.Array type. + + Use the values in the Array4D module + to manipulate values of this type, or the notation arr.[x1,x2,x3,x4] to get and set array + values. + + + Three dimensional arrays, typically zero-based. Non-zero-based arrays + can be created using methods on the System.Array type. + + Use the values in the Array3D module + to manipulate values of this type, or the notation arr.[x1,x2,x3] to get and set array + values. + + + Two dimensional arrays, typically zero-based. + + Use the values in the Array2D module + to manipulate values of this type, or the notation arr.[x,y] to get/set array + values. + + Non-zero-based arrays can also be created using methods on the System.Array type. + + + Single dimensional, zero-based arrays, written int[], string[] etc. + Use the values in the Array module to manipulate values + of this type, or the notation arr.[x] to get/set array + values. + + + Single dimensional, zero-based arrays, written int[], string[] etc. + + Use the values in the Array module to manipulate values + of this type, or the notation arr.[x] to get/set array + values. + + + + + + An abbreviation for the CLI type System.Boolean. + + + Represents a managed pointer in F# code. + + + An abbreviation for the CLI type System.Byte. + + + An abbreviation for the CLI type System.Char. + + + An abbreviation for the CLI type System.Decimal. + + + The type of decimal 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 + System.Decimal. + + + An abbreviation for the CLI type System.Double. + + + An abbreviation for the CLI type System.Exception. + + + An abbreviation for the CLI type System.Double. + + + An abbreviation for the CLI type System.Single. + + + The type of floating point 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 + System.Single. + + + The type of floating point 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 + System.Double. + + + This type is for internal use by the F# code generator. + + + An abbreviation for the CLI type System.Int32. + + + An abbreviation for the CLI type System.Int16. + + + The type of 16-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 + System.Int16. + + + An abbreviation for the CLI type System.Int32. + + + An abbreviation for the CLI type System.Int64. + + + The type of 64-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 + System.Int64. + + + An abbreviation for the CLI type System.SByte. + + + 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 + System.Int32. + + + An abbreviation for the CLI type System.IntPtr. + + + Represents an unmanaged pointer in F# code. + + This type should only be used when writing F# code that interoperates + with native code. Use of this type in F# code may result in + unverifiable code being generated. Conversions to and from the + nativeint type may be required. Values of this type can be generated + by the functions in the NativeInterop.NativePtr module. + + + An abbreviation for the CLI type System.Object. + + + The type of optional values. When used from other CLI languages the + empty option is the null value. + + Use the constructors Some and None to create values of this type. + Use the values in the Option module to manipulate values of this type, + or pattern match against the values directly. + + 'None' values will appear as the value null to other CLI languages. + Instance methods on this type will appear as static methods to other CLI languages + due to the use of null as a value representation. + + + The type of mutable references. Use the functions [:=] and [!] to get and + set values of this type. + + + An abbreviation for the CLI type System.SByte. + + + The type of 8-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 + System.SByte. + + + An abbreviation for the CLI type System.Single. + + + An abbreviation for the CLI type System.String. + + + An abbreviation for the CLI type System.UInt16. + + + An abbreviation for the CLI type System.UInt32. + + + An abbreviation for the CLI type System.UInt64. + + + An abbreviation for the CLI type System.Byte. + + + An abbreviation for the CLI type System.UIntPtr. + + + The type 'unit', which has only one value "()". This value is special and + always uses the representation 'null'. + + + + + + + + + + + + Non-exhaustive match failures will raise the MatchFailureException exception + + + The F# compiler emits implementations of this type for compiled sequence expressions. + + + The F# compiler emits implementations of this type for compiled sequence expressions. + + + The F# compiler emits implementations of this type for compiled sequence expressions. + + A new enumerator for the sequence. + + + The F# compiler emits implementations of this type for compiled sequence expressions. + + A reference to the sequence. + + A 0, 1, and 2 respectively indicate Stop, Yield, and Goto conditions for the sequence generator. + + + The F# compiler emits implementations of this type for compiled sequence expressions. + + + The F# compiler emits implementations of this type for compiled sequence expressions. + + A new sequence generator for the expression. + + + The F# compiler emits implementations of this type for compiled sequence expressions. + + + + + + + + + + + + + + + Creates an anonymous event with the given handlers. + + A function to handle adding a delegate for the event to trigger. + A function to handle removing a delegate that the event triggers. + A function to produce the delegate type the event can trigger. + + The initialized event. + + + The F# compiler emits calls to this function to implement the use operator for F# sequence + expressions. + + The resource to be used and disposed. + The input sequence. + + The result sequence. + + + The F# compiler emits calls to this function to implement the compiler-intrinsic + conversions from untyped System.Collections.IEnumerable sequences to typed sequences. + + An initializer function. + A function to iterate and test if end of sequence is reached. + A function to retrieve the current element. + + The resulting typed sequence. + + + The F# compiler emits calls to this function to + implement the try/finally operator for F# sequence expressions. + + The input sequence. + A computation to be included in an enumerator's Dispose method. + + The result sequence. + + + The F# compiler emits calls to this function to + implement the while operator for F# sequence expressions. + + A function that indicates whether iteration should continue. + The input sequence. + + The result sequence. + + + A group of functions used as part of the compiled representation of F# sequence expressions. + + + An active pattern to force the execution of values of type Lazy<_>. + + + Special prefix operator for splicing untyped expressions into quotation holes. + + + Special prefix operator for splicing typed expressions into quotation holes. + + + Builds a 2D array from a sequence of sequences of elements. + + + Builds a read-only lookup table from a sequence of key/value pairs. The key objects are indexed using generic hashing and equality. + + + Converts the argument to signed byte. + This is a direct conversion for all + primitive numeric types. For strings, the input is converted using SByte.Parse() with InvariantCulture settings. + Otherwise the operation requires and invokes a ToSByte method on the input type. + + + Converts the argument to byte. + This is a direct conversion for all + primitive numeric types. For strings, the input is converted using Byte.Parse() on strings and otherwise requires a ToByte method on the input type. + + + Converts the argument to 64-bit float. + This is a direct conversion for all + primitive numeric types. For strings, the input is converted using Double.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToDouble method on the input type. + + + Converts the argument to 32-bit float. + This is a direct conversion for all + primitive numeric types. For strings, the input is converted using Single.Parse() with InvariantCulture settings. Otherwise the operation requires and invokes a ToSingle method on the input type. + + + Builds an aysnchronous workflow using computation expression syntax. + + + Builds a set from a sequence of objects. The objects are indexed using generic comparison. + The input sequence of elements. + The created set. + + + Print to a file using the given format, and add a newline. + The file TextWriter. + The formatter. + The formatted result. + + + Print to a file using the given format. + The file TextWriter. + The formatter. + The formatted result. + + + Print to a string buffer and raise an exception with the given + result. Helper printers must return strings. + The formatter. + The formatted result. + + + Print to a string using the given format. + The formatter. + The formatted result. + + + Print to stderr using the given format, and add a newline. + The formatter. + The formatted result. + + + Print to stderr using the given format. + The formatter. + The formatted result. + + + Print to stdout using the given format, and add a newline. + The formatter. + The formatted result. + + + Print to stdout using the given format. + The formatter. + The formatted result. + + + + + + Divides a value by an integer. + The input value. + The input int. + The division result. + + + + + + Resolves to the one value for any primitive numeric type or any type with a static member called 'One' + + + Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero' + + + A compiler intrinsic that implements dynamic invocations for the DivideByInt primitive. + + + A compiler intrinsic that implements dynamic invocations to the checked '+' operator. + + + A compiler intrinsic that implements dynamic invocations to the '+' operator. + + + A compiler intrinsic that implements dynamic invocations to the checked '+' operator. + + + A compiler intrinsic that implements dynamic invocations to the '+' operator. + + + Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'. + + + Resolves to the zero value for any primitive numeric type or any type with a static member called 'Zero'. + + + Parse an uint64 according to the rules used by the overloaded 'uint64' conversion operator when applied to strings + The input string. + The parsed value. + + + Parse an int64 according to the rules used by the overloaded 'int64' conversion operator when applied to strings + The input string. + The parsed value. + + + Parse an uint32 according to the rules used by the overloaded 'uint32' conversion operator when applied to strings + The input string. + The parsed value. + + + Parse an int32 according to the rules used by the overloaded 'int32' conversion operator when applied to strings + The input string. + The parsed value. + + + Creates an sbyte value with units-of-measure + The input sbyte. + The sbyte with units-of-measure. + + + Creates an int16 value with units-of-measure + The input int16. + The int16 with units-of-measure. + + + Creates an int64 value with units-of-measure + The input int64. + The int64 with units of measure. + + + Creates an int32 value with units-of-measure + The input int. + The int with units of measure. + + + Creates a decimal value with units-of-measure + The input decimal. + The decimal with units of measure. + + + Creates a float32 value with units-of-measure + The input float. + The float with units-of-measure. + + + Creates a float value with units-of-measure + The input float. + The float with units-of-measure. + + + Get the underlying value for an enum value + The input enum. + The enumeration as a value. + + + Build an enum value from an underlying value + The input value. + The value as an enumeration. + + + Recursively hash a part of a value according to its structure. + The comparison function. + The input object. + The hashed value. + + + Hash a value according to its structure. Use the given limit to restrict the hash when hashing F# + records, lists and union types. + The limit on the number of nodes. + The input object. + The hashed value. + + + Hash a value according to its structure. This hash is not limited by an overall node count when hashing F# + records, lists and union types. + The input object. + The hashed value. + + + Make an F# hash/equality object for the given type using node-limited hashing when hashing F# + records, lists and union types. + The input limit on the number of nodes. + System.Collections.Generic.IEqualityComparer<'T> + + + Make an F# hash/equality object for the given type + + + Make an F# comparer object for the given type, where it can be null if System.Collections.Generic.Comparer<'T>.Default + + + Make an F# comparer object for the given type + + + A static F# comparer object + + + Return an F# comparer object suitable for hashing and equality. This hashing behaviour + of the returned comparer is not limited by an overall node count when hashing F# + records, lists and union types. This equality comparer has equivalence + relation semantics ([nan] = [nan]). + + + Return an F# comparer object suitable for hashing and equality. This hashing behaviour + of the returned comparer is not limited by an overall node count when hashing F# + records, lists and union types. + + + The physical hash. Hashes on the object identity, except for value types, + where we hash on the contents. + The input object. + The hashed value. + + + Reference/physical equality. + True if boxed versions of the inputs are reference-equal, OR if + both are primitive numeric types and the implementation of Object.Equals for the type + of the first argument returns true on the boxed versions of the inputs. + The first value. + The second value. + The result of the comparison. + + + Take the maximum of two values structurally according to the order given by GenericComparison + The first value. + The second value. + The maximum value. + + + Take the minimum of two values structurally according to the order given by GenericComparison + The first value. + The second value. + The minimum value. + + + Compare two values + The first value. + The second value. + The result of the comparison. + + + Compare two values + The first value. + The second value. + The result of the comparison. + + + Compare two values + The first value. + The second value. + The result of the comparison. + + + Compare two values + The first value. + The second value. + The result of the comparison. + + + Compare two values. May be called as a recursive case from an implementation of System.IComparable to + ensure consistent NaN comparison semantics. + The function to compare the values. + The first value. + The second value. + The result of the comparison. + + + Compare two values + The first value. + The second value. + The result of the comparison. + + + Compare two values for equality + + The first value. + The second value. + The result of the comparison. + + + Compare two values for equality using equivalence relation semantics ([nan] = [nan]) + The first value. + The second value. + The result of the comparison. + + + Compare two values for equality using partial equivalence relation semantics ([nan] <> [nan]) + The first value. + The second value. + The result of the comparison. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + A primitive entry point used by the F# compiler for optimization purposes. + + + The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs + + + + The standard overloaded associative (4-indexed) mutation operator + + + + The standard overloaded associative (3-indexed) mutation operator + + + The standard overloaded associative (2-indexed) mutation operator + + + The standard overloaded associative (indexed) mutation operator + + + The standard overloaded associative (4-indexed) lookup operator + + + The standard overloaded associative (3-indexed) lookup operator + + + The standard overloaded associative (2-indexed) lookup operator + + + The standard overloaded associative (indexed) lookup operator + + + A compiler intrinsic for checking initialization soundness of recursive bindings + + + A compiler intrinsic for checking initialization soundness of recursive static bindings + + + A compiler intrinsic for checking initialization soundness of recursive bindings + + + A compiler intrinsic for the efficient compilation of sequence expressions + + + This function implements parsing of decimal constants + + + This function implements calls to default constructors + acccessed by 'new' constraints. + + + Primitive used by pattern match compilation + + + A compiler intrinsic that implements the ':?' operator + + + A compiler intrinsic that implements the ':?' operator + + + A compiler intrinsic that implements the ':?>' operator + + + A compiler intrinsic that implements the ':?>' operator + + + The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs + + + Address-of. Uses of this value may result in the generation of unverifiable code. + The input object. + The unmanaged pointer. + + + Address-of. Uses of this value may result in the generation of unverifiable code. + The input object. + The managed pointer. + + + Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand + The first value. + The second value. + The result of the operation. + + + Binary 'or'. When used as a binary operator the right hand value is evaluated only on demand. + + + Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand + The first value. + The second value. + The result of the operation. + + + Binary 'and'. When used as a binary operator the right hand value is evaluated only on demand. + + + The F# compiler emits calls to some of the functions in this module as part of the compiled form of some language constructs + + + + + + + + + + + + + + + + + + For internal use only + + + Language primitives associated with the F# language + + + + Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI' + + + + + Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI' + + + + + Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI' + + + + + Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI' + + + + + Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI' + + + + + Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI' + + + + + Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI' + + + + + Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI' + + + + + Provides a default implementations of F# numeric literal syntax for literals fo the form 'dddI' + + + + An active pattern to match values of type System.Collections.Generic.KeyValuePair + The input key/value pair. + A tuple containing the key and value. + + + Converts the argument to character. Numeric inputs are converted according to the UTF-16 + encoding for characters. String inputs must be exactly one character long. For other + input types the operation requires an appropriate static conversion method on the input type. + The input value. + The converted char. + + + Converts the argument to System.Decimal using a direct conversion for all + primitive numeric types. For strings, the input is converted using UInt64.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted decimal. + + + Converts the argument to a string using ToString. + + For standard integer and floating point values the ToString conversion + uses CultureInfo.InvariantCulture. + The input value. + The converted string. + + + Converts the argument to unsigned native integer using a direct conversion for all + primitive numeric types. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted unativeint + + + Converts the argument to signed native integer. This is a direct conversion for all + primitive numeric types. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted nativeint + + + Converts the argument to 64-bit float. This is a direct conversion for all + primitive numeric types. For strings, the input is converted using Double.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted float + + + Converts the argument to 32-bit float. This is a direct conversion for all + primitive numeric types. For strings, the input is converted using Single.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted float32 + + + Converts the argument to unsigned 64-bit integer. This is a direct conversion for all + primitive numeric types. For strings, the input is converted using UInt64.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted uint64 + + + Converts the argument to signed 64-bit integer. This is a direct conversion for all + primitive numeric types. For strings, the input is converted using Int64.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted int64 + + + Converts the argument to unsigned 32-bit integer. This is a direct conversion for all + primitive numeric types. For strings, the input is converted using UInt32.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted uint32 + + + 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 Int32.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted int32 + + + Converts the argument to a particular enum type. + The input value. + The converted enum type. + + + 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 Int32.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted int + + + Converts the argument to unsigned 16-bit integer. This is a direct conversion for all + primitive numeric types. For strings, the input is converted using UInt16.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted uint16 + + + Converts the argument to signed 16-bit integer. This is a direct conversion for all + primitive numeric types. For strings, the input is converted using Int16.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted int16 + + + Converts the argument to signed byte. This is a direct conversion for all + primitive numeric types. For strings, the input is converted using SByte.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted sbyte + + + Converts the argument to byte. This is a direct conversion for all + primitive numeric types. For strings, the input is converted using Byte.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted byte + + + Overloaded power operator. If n > 0 then equivalent to x*...*x for n occurrences of x. + The input base. + The input exponent. + The base raised to the exponent. + + + Overloaded power operator. + The input base. + The input exponent. + The base raised to the exponent. + + + Overloaded truncate operator. + The input value. + The truncated value. + + + Hyperbolic tangent of the given number + The input value. + The hyperbolic tangent of the input. + + + Tangent of the given number + The input value. + The tangent of the input. + + + Hyperbolic sine of the given number + The input value. + The hyperbolic sine of the input. + + + Sine of the given number + The input value. + The sine of the input. + + + Hyperbolic cosine of the given number + The input value. + The hyperbolic cosine of the input. + + + Cosine of the given number + The input value. + The cosine of the input. + + + Square root of the given number + The input value. + The square root of the input. + + + Logarithm to base 10 of the given number + The input value. + The logarithm to base 10 of the input. + + + Natural logarithm of the given number + The input value. + The natural logarithm of the input. + + + Round the given number + The input value. + The nearest integer to the input value. + + + Sign of the given number + The input value. + -1, 0, or 1 depending on the sign of the input. + + + Floor of the given number + The input value. + The floor of the input. + + + Exponential of the given number + The input value. + The exponential of the input. + + + Ceiling of the given number + The input value. + The ceiling of the input. + + + Inverse tangent of x/y where x and y are specified separately + The y input value. + The x input value. + The inverse tangent of the input ratio. + + + Inverse tangent of the given number + The input value. + The inverse tangent of the input. + + + Inverse sine of the given number + The input value. + The inverse sine of the input. + + + Inverse cosine of the given number + The input value. + The inverse cosine of the input. + + + Absolute value of the given number. + The input value. + The absolute value of the input. + + + A generic hash function. This function has the same behaviour as 'hash', + however the default structural hashing for F# union, record and tuple + types stops when the given limit of nodes is reached. The exact behaviour of + the function can be adjusted on a type-by-type basis by implementing + GetHashCode for each type. + The limit of nodes. + The input object. + The computed hash. + + + A generic hash function, designed to return equal hash values for items that are + equal according to the "=" operator. By default it will use structural hashing + for F# union, record and tuple types, hashing the complete contents of the + type. The exact behaviour of the function can be adjusted on a + type-by-type basis by implementing GetHashCode for each type. + The input object. + The computed hash. + + + Returns the internal size of a type in bytes. For example, sizeof<int> returns 4. + + + Generate a System.Type representation for a type definition. If the + input type is a generic type instantiation then return the + generic type definition associated with all such instantiations. + + + Generate a System.Type runtime representation of a static type. + The static type is still maintained on the value returned. + + + Clean up resources associated with the input object after the completion of the given function. + Cleanup occurs even when an exception is raised by the protected + code. + The resource to be disposed after action is called. + The action that accepts the resource. + The resulting value. + + + Execute the function as a mutual-exclusion region using the input value as a lock. + The object to be locked. + The action to perform during the lock. + The resulting value. + + + The standard overloaded skip range operator, e.g. [n..skip..m] for lists, seq {n..skip..m} for sequences + The start value of the range. + The step value of the range. + The end value of the range. + The sequence spanning the range using the specified step size. + + + The standard overloaded range operator, e.g. [n..m] for lists, seq {n..m} for sequences + The start value of the range. + The end value of the range. + The sequence spanning the range. + + + Reads the value of the property System.Console.Out. + + + Reads the value of the property System.Console.Error. + + + Reads the value of the property System.Console.In. + + + Equivalent to System.Single.NaN + + + Equivalent to System.Single.PositiveInfinity + + + Equivalent to System.Double.NaN + + + Equivalent to System.Double.PositiveInfinity + + + Exit the current hardware isolated process, if security settings permit, + otherwise raise an exception. Calls System.Environment.Exit. + The exit code to use. + The result value. + + + Builds a sequence using sequence expression syntax + The input sequence. + The result sequence. + + + Negate a logical value. not true equals false and not false equals true + The value to negate. + The result of the negation. + + + Concatenate two lists. + The first list. + The second list. + The concatenation of the lists. + + + Increment a mutable reference cell containing an integer + The reference cell. + + + Decrement a mutable reference cell containing an integer + The reference cell. + + + Dereference a mutable reference cell + The cell to dereference. + The value contained in the cell. + + + Assign to a mutable reference cell + The cell to mutate. + The value to set inside the cell. + + + Create a mutable reference cell + The value to contain in the cell. + The created reference cell. + + + The identity function + The input value. + The same value. + + + Throw an System.InvalidOperationException exception + The exception message. + The result value. + + + Throw an System.ArgumentNullException exception + The argument name. + The result value. + + + Throw an System.ArgumentException exception + The argument name. + The exception message. + The result value. + + + Throw a System.Exception exception + The exception message. + The result value. + + + Boxes a strongly typed value. + The value to box. + The boxed object. + + + Unboxes a strongly typed value. This is the inverse of box, unbox<t>(box<t> a) equals a. + The boxed value. + The unboxed result. + + + Ignore the passed value. This is often used to throw away results of a computation. + The value to ignore. + + + Minimum based on generic comparison + The first value. + The second value. + The minimum value. + + + Maximum based on generic comparison + The first value. + The second value. + The maximum value. + + + Generic comparison. + The first value. + The second value. + The result of the comparison. + + + Return the second element of a tuple, snd (a,b) = b. + The input tuple. + The second value. + + + Return the first element of a tuple, fst (a,b) = a. + The input tuple. + The first value. + + + Matches System.Exception objects whose runtime type is precisely System.Exception + The input exception. + A string option. + + + Builds a System.Exception object. + The message for the Exception. + A System.Exception. + + + Rethrows an exception. This should only be used when handling an exception + The result value. + + + Rethrows an exception. This should only be used when handling an exception + The result value. + + + Raises an exception + The exception to raise. + The result value. + + + Concatenate two strings. The operator '+' may also be used. + + + Used to specify a default value for an optional argument in the implementation of a function + An option representing the argument. + The default value of the argument. + The argument value. If it is None, the defaultValue is returned. + + + Apply a function to three values, the values being a triple on the right, the function on the left + The function. + The first argument. + The second argument. + The third argument. + The function result. + + + Apply a function to two values, the values being a pair on the right, the function on the left + The function. + The first argument. + The second argument. + The function result. + + + Apply a function to a value, the value being on the right, the function on the left + The function. + The argument. + The function result. + + + Apply a function to three values, the values being a triple on the left, the function on the right + The first argument. + The second argument. + The third argument. + The function. + The function result. + + + Apply a function to two values, the values being a pair on the left, the function on the right + The first argument. + The second argument. + The function. + The function result. + + + Apply a function to a value, the value being on the left, the function on the right + The argument. + The function. + The function result. + + + Compose two functions, the function on the right being applied first + The second function to apply. + The first function to apply. + The composition of the input functions. + + + Compose two functions, the function on the left being applied first + The first function to apply. + The second function to apply. + The composition of the input functions. + + + Structural inequality + The first parameter. + The second parameter. + The result of the comparison. + + + Structural equality + The first parameter. + The second parameter. + The result of the comparison. + + + Structural less-than-or-equal comparison + The first parameter. + The second parameter. + The result of the comparison. + + + Structural greater-than-or-equal + The first parameter. + The second parameter. + The result of the comparison. + + + Structural greater-than + The first parameter. + The second parameter. + The result of the comparison. + + + Structural less-than comparison + The first parameter. + The second parameter. + The result of the comparison. + + + Overloaded prefix=plus operator + The input value. + The result of the operation. + + + Overloaded logical-NOT operator + The input value. + The result of the operation. + + + Overloaded byte-shift right operator by a specified number of bits + The input value. + The amount to shift. + The result of the operation. + + + Overloaded byte-shift left operator by a specified number of bits + The input value. + The amount to shift. + The result of the operation. + + + Overloaded logical-XOR operator + The first parameter. + The second parameter. + The result of the operation. + + + Overloaded logical-OR operator + The first parameter. + The second parameter. + The result of the operation. + + + Overloaded logical-AND operator + The first parameter. + The second parameter. + The result of the operation. + + + Overloaded modulo operator + The first parameter. + The second parameter. + The result of the operation. + + + Overloaded division operator + The first parameter. + The second parameter. + The result of the operation. + + + Overloaded multiplication operator + The first parameter. + The second parameter. + The result of the operation. + + + Overloaded subtraction operator + The first parameter. + The second parameter. + The result of the operation. + + + Overloaded addition operator + The first parameter. + The second parameter. + The result of the operation. + + + Overloaded unary negation. + The value to negate. + The result of the operation. + + + Converts the argument to char. Numeric inputs are converted using a checked + conversion according to the UTF-16 encoding for characters. String inputs must + be exactly one character long. For other input types the operation requires an + appropriate static conversion method on the input type. + The input value. + The converted char + + + Converts the argument to unativeint. This is a direct, checked conversion for all + primitive numeric types. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted unativeint + + + Converts the argument to nativeint. This is a direct, checked conversion for all + primitive numeric types. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted nativeint + + + Converts the argument to uint64. This is a direct, checked conversion for all + primitive numeric types. For strings, the input is converted using System.UInt64.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted uint64 + + + Converts the argument to int64. This is a direct, checked conversion for all + primitive numeric types. For strings, the input is converted using System.Int64.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted int64 + + + Converts the argument to uint32. This is a direct, checked conversion for all + primitive numeric types. For strings, the input is converted using System.UInt32.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted uint32 + + + Converts the argument to int32. This is a direct, checked conversion for all + primitive numeric types. For strings, the input is converted using System.Int32.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted int32 + + + Converts the argument to int. This is a direct, checked conversion for all + primitive numeric types. For strings, the input is converted using System.Int32.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted int + + + Converts the argument to uint16. This is a direct, checked conversion for all + primitive numeric types. For strings, the input is converted using System.UInt16.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted uint16 + + + Converts the argument to int16. This is a direct, checked conversion for all + primitive numeric types. For strings, the input is converted using System.Int16.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted int16 + + + Converts the argument to sbyte. This is a direct, checked conversion for all + primitive numeric types. For strings, the input is converted using System.SByte.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted sbyte + + + Converts the argument to byte. This is a direct, checked conversion for all + primitive numeric types. For strings, the input is converted using System.Byte.Parse() + with InvariantCulture settings. Otherwise the operation requires an appropriate + static conversion method on the input type. + The input value. + The converted byte + + + Overloaded multiplication operator (checks for overflow) + The first value. + The second value. + The product of the two input values. + + + Overloaded addition operator (checks for overflow) + The first value. + The second value. + The sum of the two input values. + + + Overloaded subtraction operator (checks for overflow) + The first value. + The second value. + The first value minus the second value. + + + Overloaded unary negation (checks for overflow) + The input value. + The negated value. + + + This module contains the basic arithmetic operations with overflow checks. + + + Perform generic hashing on a value where the type of the value is not + statically required to satisfy the 'equality' constraint. + The computed hash value. + + + Perform generic equality on two values where the type of the values is not + statically required to satisfy the 'equality' constraint. + The result of the comparison. + + + Perform generic comparison on two values where the type of the values is not + statically required to have the 'comparison' constraint. + The result of the comparison. + + + Generate a default value for any type. This is null for reference types, + For structs, this is struct value where all fields have the default value. + This function is unsafe in the sense that some F# values do not have proper null values. + + + This module contains basic operations which do not apply runtime and/or static checks + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'decimal' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'float32' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'unativeint' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'nativeint' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint64' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int64' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint32' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int32' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'uint16' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'int16' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'sbyte' + + + This is a library intrinsic. Calls to this function may be generated by uses of the generic 'pown' operator on values of type 'byte' + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + This is a library intrinsic. Calls to this function may be generated by evaluating quotations. + + + Generate a range of values using the given zero, add, start, step and stop values + + + Generate a range of values using the given zero, add, start, step and stop values + + + Generate a range of char values + + + Generate a range of byte values + + + Generate a range of sbyte values + + + Generate a range of uint16 values + + + Generate a range of int16 values + + + Generate a range of unativeint values + + + Generate a range of nativeint values + + + Generate a range of uint32 values + + + Generate a range of uint64 values + + + Generate a range of int64 values + + + Generate a range of float32 values + + + Generate a range of float values + + + Generate a range of integers + + + Gets a slice from a string + The source string. + The index of the first character of the slice. + The index of the last character of the slice. + The substring from the given indices. + + + Sets a slice of an array + The target array. + The start index of the first dimension. + The end index of the first dimension. + The start index of the second dimension. + The end index of the second dimension. + The start index of the third dimension. + The end index of the third dimension. + The start index of the fourth dimension. + The end index of the fourth dimension. + The source array. + + + Gets a slice of an array + The source array. + The start index of the first dimension. + The end index of the first dimension. + The start index of the second dimension. + The end index of the second dimension. + The start index of the third dimension. + The end index of the third dimension. + The start index of the fourth dimension. + The end index of the fourth dimension. + The four dimensional sub array from the given indices. + + + Sets a slice of an array + The target array. + The start index of the first dimension. + The end index of the first dimension. + The start index of the second dimension. + The end index of the second dimension. + The start index of the third dimension. + The end index of the third dimension. + The source array. + + + Gets a slice of an array + The source array. + The start index of the first dimension. + The end index of the first dimension. + The start index of the second dimension. + The end index of the second dimension. + The start index of the third dimension. + The end index of the third dimension. + The three dimensional sub array from the given indices. + + + Sets a slice of an array + The target array. + The start index of the first dimension. + The end index of the first dimension. + The start index of the second dimension. + The end index of the second dimension. + The source array. + + + Gets a slice of an array + The source array. + The start index of the first dimension. + The end index of the first dimension. + The start index of the second dimension. + The end index of the second dimension. + The two dimensional sub array from the input indices. + + + Sets a slice of an array + The target array. + The start index. + The end index. + The source array. + + + Gets a slice of an array + The input array. + The start index. + The end index. + The sub array from the input indices. + + + A module of compiler intrinsic functions for efficient implementations of F# integer ranges + and dynamic invocations of other F# operators + + + Basic F# Operators. This module is automatically opened in all F# code. + + + Invoke an F# first class function value that accepts five curried arguments + without intervening execution + The first arg. + The second arg. + The third arg. + The fourth arg. + The fifth arg. + The function result. + + + Adapt an F# first class function value to be an optimized function value that can + accept five curried arguments without intervening execution. + The input function. + The optimized function. + + + Construct an optimized function value that can accept five curried + arguments without intervening execution. + The optimized function. + + + The CLI type used to represent F# function values that accept five curried arguments + without intervening execution. This type should not typically used directly from + either F# code or from other CLI languages. + + + Invoke an F# first class function value that accepts four curried arguments + without intervening execution + The first arg. + The second arg. + The third arg. + The fourth arg. + The function result. + + + Adapt an F# first class function value to be an optimized function value that can + accept four curried arguments without intervening execution. + The input function. + The optimized function. + + + Construct an optimized function value that can accept four curried + arguments without intervening execution. + The optimized function. + + + The CLI type used to represent F# function values that accept four curried arguments + without intervening execution. This type should not typically used directly from + either F# code or from other CLI languages. + + + Invoke an F# first class function value that accepts three curried arguments + without intervening execution + The first arg. + The second arg. + The third arg. + The function result. + + + Adapt an F# first class function value to be an optimized function value that can + accept three curried arguments without intervening execution. + The input function. + The adapted function. + + + Construct an optimized function value that can accept three curried + arguments without intervening execution. + The optimized function. + + + The CLI type used to represent F# function values that accept + three iterated (curried) arguments without intervening execution. This type should not + typically used directly from either F# code or from other CLI languages. + + + Invoke the optimized function value with two curried arguments + The first arg. + The second arg. + The function result. + + + Adapt an F# first class function value to be an optimized function value that can + accept two curried arguments without intervening execution. + The input function. + The adapted function. + + + Construct an optimized function value that can accept two curried + arguments without intervening execution. + The optimized function. + + + The CLI type used to represent F# function values that accept + two iterated (curried) arguments without intervening execution. This type should not + typically used directly from either F# code or from other CLI languages. + + + An implementation module used to hold some private implementations of function + value invocation. + + + Convert the option to a list of length 0 or 1. + The input option. + The result list. + + + Convert the option to an array of length 0 or 1. + The input option. + The result array. + + + bind f inp evaluates to match inp with None -> None | Some x -> f x + A function that takes the value of type T from an option and transforms it into + an option containing a value of type U. + The input option. + An option of the output type of the binder. + + + map f inp evaluates to match inp with None -> None | Some x -> Some (f x). + A function to apply to the option value. + The input option. + An option of the input value after applying the mapping function, or None if the input is None. + + + iter f inp executes match inp with None -> () | Some x -> f x. + A function to apply to the option value. + The input option. + Unit if the option is None, otherwise it returns the result of applying the predicate + to the option value. + + + forall p inp" evaluates to "match inp with None -> true | Some x -> p x. + A function that evaluates to a boolean when given a value from the option type. + The input option. + True if the option is None, otherwise it returns the result of applying the predicate + to the option value. + + + exists p inp evaluates to match inp with None -> false | Some x -> p x. + A function that evaluates to a boolean when given a value from the option type. + The input option. + False if the option is None, otherwise it returns the result of applying the predicate + to the option value. + + + fold f inp s evaluates to match inp with None -> s | Some x -> f x s. + A function to update the state data when given a value from an option. + The input option. + The initial state. + The original state if the option is None, otherwise it returns the updated state with the folder + and the option value. + + + fold f s inp evaluates to match inp with None -> s | Some x -> f s x. + A function to update the state data when given a value from an option. + The initial state. + The input option. + The original state if the option is None, otherwise it returns the updated state with the folder + and the option value. + + + count inp evaluates to match inp with None -> 0 | Some _ -> 1. + The input option. + A zero if the option is None, a one otherwise. + + + Gets the value associated with the option. + The input option. + The value within the option. + Thrown when the option is None. + + + Returns true if the option is None. + The input option. + True if the option is None. + + + Returns true if the option is not None. + The input option. + True if the option is not None. + + + Basic operations on options. + + + Represents a statically-analyzed format associated with writing to a System.IO.TextWriter. The type parameter indicates the + arguments and return type of the format operation. + + + Represents a statically-analyzed format when formatting builds a string. The type parameter indicates the + arguments and return type of the format operation. + + + Represents a statically-analyzed format associated with writing to a System.Text.StringBuilder. The type parameter indicates the + arguments and return type of the format operation. + + + Represents a statically-analyzed format associated with writing to a System.IO.TextWriter. The first type parameter indicates the + arguments of the format operation and the last the overall return type. + + + Represents a statically-analyzed format when formatting builds a string. The first type parameter indicates the + arguments of the format operation and the last the overall return type. + + + Represents a statically-analyzed format associated with writing to a System.Text.StringBuilder. The first type parameter indicates the + arguments of the format operation and the last the overall return type. + + + Print to a string buffer and raise an exception with the given + result. Helper printers must return strings. + The input formatter. + The arguments of the formatter. + + + sprintf, but call the given 'final' function to generate the result. + See kprintf. + The function called to generate a result from the formatted string. + The input formatter. + The arguments of the formatter. + + + printf, but call the given 'final' function to generate the result. + For example, these let the printing force a flush after all output has + been entered onto the channel, but not before. + The function called after formatting to generate the format result. + The input formatter. + The arguments of the formatter. + + + fprintf, but call the given 'final' function to generate the result. + See kprintf. + The function called after formatting to generate the format result. + The input TextWriter. + The input formatter. + The arguments of the formatter. + + + bprintf, but call the given 'final' function to generate the result. + See kprintf. + The function called after formatting to generate the format result. + The input StringBuilder. + The input formatter. + The arguments of the formatter. + + + Print to a string via an internal string buffer and return + the result as a string. Helper printers must return strings. + The input formatter. + The formatted string. + + + Formatted printing to stdout, adding a newline. + The input formatter. + The return type and arguments of the formatter. + + + Formatted printing to stdout + The input formatter. + The return type and arguments of the formatter. + + + Formatted printing to stderr, adding a newline + The input formatter. + The return type and arguments of the formatter. + + + Formatted printing to stderr + The input formatter. + The return type and arguments of the formatter. + + + Print to a text writer, adding a newline + The TextWriter to print to. + The input formatter. + The return type and arguments of the formatter. + + + Print to a text writer. + The TextWriter to print to. + The input formatter. + The return type and arguments of the formatter. + + + Print to a System.Text.StringBuilder + The StringBuilder to print to. + The input formatter. + The return type and arguments of the formatter. + + + Extensible printf-style formatting for numbers and other datatypes + + Format specifications are strings with "%" markers indicating format + placeholders. Format placeholders consist of: + + %[flags][width][.precision][type] + + where the type is interpreted as follows: + + %b: bool, formatted as "true" or "false" + %s: string, formatted as its unescaped contents + %d, %i: any basic integer type formatted as a decimal integer, signed if the basic integer type is signed. + %u: any basic integer type formatted as an unsigned decimal integer + %x, %X, %o: any basic integer type formatted as an unsigned hexadecimal + (a-f)/Hexadecimal (A-F)/Octal integer + + %e, %E, %f, %F, %g, %G: + any basic floating point type (float,float32) formatted + using a C-style floating point format specifications, i.e + + %e, %E: Signed value having the form [-]d.dddde[sign]ddd where + d is a single decimal digit, dddd is one or more decimal + digits, ddd is exactly three decimal digits, and sign + is + or - + + %f: Signed value having the form [-]dddd.dddd, where dddd is one + or more decimal digits. The number of digits before the + decimal point depends on the magnitude of the number, and + the number of digits after the decimal point depends on + the requested precision. + + %g, %G: Signed value printed in f or e format, whichever is + more compact for the given value and precision. + + + %M: System.Decimal value + + %O: Any value, printed by boxing the object and using it's ToString method(s) + + %A: Any value, printed with the default layout settings + + %a: A general format specifier, requires two arguments: + (1) a function which accepts two arguments: + (a) a context parameter of the appropriate type for the + given formatting function (e.g. an #System.IO.TextWriter) + (b) a value to print + and which either outputs or returns appropriate text. + + (2) the particular value to print + + + %t: A general format specifier, requires one argument: + (1) a function which accepts a context parameter of the + appropriate type for the given formatting function (e.g. + an System.IO.TextWriter)and which either outputs or returns + appropriate text. + + Basic integer types are: + byte,sbyte,int16,uint16,int32,uint32,int64,uint64,nativeint,unativeint + Basic floating point types are: + float, float32 + + The optional width is an integer indicating the minimal width of the + result. For instance, %6d prints an integer, prefixing it with spaces + to fill at least 6 characters. If width is '*', then an extra integer + argument is taken to specify the corresponding width. + + any number + '*': + + Valid flags are: + + 0: add zeros instead of spaces to make up the required width + '-': left justify the result within the width specified + '+': add a '+' character if the number is positive (to match a '-' sign + for negatives) + ' ': add an extra space if the number is positive (to match a '-' + sign for negatives) + + The printf '#' flag is invalid and a compile-time error will be reported if it is used. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Returns the length of the string. + The input string. + The number of characters in the string. + Thrown when the input string is null. + + + Returns a string by concatenating count instances of str. + The number of copies of the input string will be copied. + The input string. + The concatenated string. + Thrown when the input string is null. + + + Tests if any character of the string satisfies the given predicate. + The function to test each character of the string. + The input string. + True if any character returns true for the predicate and false otherwise. + Thrown when the input string is null. + + + Tests if all characters in the string satisfy the given predicate. + The function to test each character of the string. + The input string. + True if all characters return true for the predicate and false otherwise. + Thrown when the input string is null. + + + Builds a new string whose characters are the results of applying the function mapping + to each index from 0 to count-1 and concatenating the resulting + strings. + The number of strings to initialize. + The function to take an index and produce a string to + be concatenated with the others. + The constructed string. + Thrown when count is negative. + + + Builds a new string whose characters are the results of applying the function mapping + to each of the characters of the input string and concatenating the resulting + strings. + The function to produce a string from each character of the input string. + The input string. + The concatenated string. + Thrown when the input string is null. + + + Builds a new string whose characters are the results of applying the function mapping + to each character and index of the input string. + The function to apply to each character and index of the string. + The input string. + The resulting string. + Thrown when the input string is null. + + + Builds a new string whose characters are the results of applying the function mapping + to each of the characters of the input string. + The function to apply to the characters of the string. + The input string. + The resulting string. + Thrown when the input string is null. + + + Applies the function action to the index of each character in the string and the + character itself. + The function to apply to each character and index of the string. + The input string. + Thrown when the input string is null. + + + Applies the function action to each character in the string. + The function to be applied to each character of the string. + The input string. + Thrown when the input string is null. + + + Returns a new string made by concatenating the given strings + with separator sep, that is a1 + sep + ... + sep + aN. + The separator string to be inserted between the strings + of the input sequence. + The sequence of strings to be concatenated. + A new string consisting of the concatenated strings separated by + the separation string. + Thrown when strings is null. + + + Functional programming operators for string processing. Further string operations + are available via the member functions on strings and other functionality in + System.String + and System.Text.RegularExpressions types. + + + Allocates a region of memory on the stack. + The number of objects of type T to allocate. + A typed pointer to the allocated memory. + + + Assigns the value into the memory location referenced by the typed native + pointer computed by adding index * sizeof<'T> to the given input pointer. + The input pointer. + The index by which to offset the pointer. + The value to assign. + + + Assigns the value into the memory location referenced by the given typed native pointer. + The input pointer. + The value to assign. + + + Dereferences the given typed native pointer. + The input pointer. + The value at the pointer address. + + + Dereferences the typed native pointer computed by adding index * sizeof<'T> to the + given input pointer. + The input pointer. + The index by which to offset the pointer. + The value at the pointer address. + + + Returns a typed native pointer by adding index * sizeof<'T> to the + given input pointer. + The input pointer. + The index by which to offset the pointer. + A typed pointer. + + + Returns a machine address for a given typed native pointer. + The input pointer. + The machine address. + + + Returns a typed native pointer for a given machine address. + The pointer address. + A typed pointer. + + + Contains operations on native pointers. Use of these operators may + result in the generation of unverifiable code. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the raw expression associated with this type-carrying expression + + + Type-carrying quoted expressions. Expressions are generated either + by quotations in source text or programatically + + + Returns type of an expression. + + + Returns the custom attributes of an expression. + + + Builds an expression that represents a while loop + The predicate to control the loop iteration. + The body of the while loop. + The resulting expression. + + + Builds an expression that represents setting a mutable variable + The input variable. + The value to set. + The resulting expression. + + + Builds an expression that represents a variable + The input variable. + The resulting expression. + + + Builds an expression that represents a constant value + The typed value. + The resulting expression. + + + Builds an expression that represents a constant value of a particular type + The untyped object. + The type of the object. + The resulting expression. + + + Builds an expression that represents a test of a value is of a particular union case + The expression to test. + The description of the union case. + The resulting expression. + + + Builds an expression that represents a type test. + The expression to test. + The target type. + The resulting expression. + + + Builds an expression that represents getting a field of a tuple + The input tuple. + The index of the tuple element to get. + The resulting expression. + + + Builds an expression that represents a try/with construct for exception filtering and catching. + The body of the try expression. + + + The variable to bind to a caught exception. + The expression evaluated when an exception is caught. + The resulting expression. + + + Try and find a stored reflection definition for the given method. Stored reflection + definitions are added to an F# assembly through the use of the [<ReflectedDefinition>] attribute. + The description of the method to find. + The reflection definition or None if a match could not be found. + + + Builds an expression that represents a try/finally construct + The body of the try expression. + The final part of the expression to be evaluated. + The resulting expression. + + + Substitutes through the given expression using the given functions + to map variables to new values. The functions must give consistent results + at each application. Variable renaming may occur on the target expression + if variable capture occurs. + The function to map variables into expressions. + The expression with the given substitutions. + + + Builds an expression that represents the sequential execution of one expression followed by another + The first expression. + The second expression. + The resulting expression. + + + Permits interactive environments such as F# Interactive + to explicitly register new pickled resources that represent persisted + top level definitions. The string indicates a unique name for the resources + being added. The format for the bytes is the encoding generated by the F# compiler. + The assembly associated with the resource. + The unique name for the resources being added. + The serialized resource to register with the environment. + + + Builds an expression that represents a nested quotation literal + The expression being quoted. + The resulting expression. + + + Builds an expression that represents writing to a static property + The description of the property. + The value to set. + List of indices for the property if it is an indexed property. + The resulting expression. + + + Builds an expression that represents writing to a property of an object + The input object. + The description of the property. + The value to set. + List of indices for the property if it is an indexed property. + The resulting expression. + + + Builds an expression that represents reading a static property + The description of the property. + List of indices for the property if it is an indexed property. + The resulting expression. + + + Builds an expression that represents reading a property of an object + The input object. + The description of the property. + List of indices for the property if it is an indexed property. + The resulting expression. + + + Builds an expression that represents the creation of a union case value + The description of the union case. + The list of arguments for the case. + The resulting expression. + + + Builds an expression that represents the creation of an F# tuple value + The list of elements of the tuple. + The resulting expression. + + + Builds record-construction expressions + The type of record. + The list of elements of the record. + The resulting expression. + + + Builds an expression that represents the invocation of an object constructor + The description of the constructor. + The list of arguments to the constructor. + The resulting expression. + + + Builds an expression that represents the creation of a delegate value for the given type + The type of delegate. + The parameters for the delegate. + The body of the function. + The resulting expression. + + + Builds an expression that represents the creation of an array value initialized with the given elements + The type for the elements of the array. + The list of elements of the array. + The resulting expression. + + + Builds recursives expressions associated with 'let rec' constructs + The list of bindings for the let expression. + The sub-expression where the bindings are in scope. + The resulting expression. + + + Builds expressions associated with 'let' constructs + The variable in the let expression. + The expression bound to the variable. + The sub-expression where the binding is in scope. + The resulting expression. + + + Builds an expression that represents the constrution of an F# function value + The parameter to the function. + The body of the function. + The resulting expression. + + + Builds 'if ... then ... else' expressions. + The condition expression. + The then sub-expression. + The else sub-expression. + The resulting expression. + + + Fetches or creates a new variable with the given name and type from a global pool of shared variables + indexed by name and type. The type is given by the expicit or inferred type parameter + The variable name. + The created of fetched typed global variable. + + + Gets the free expression variables of an expression as a list. + A sequence of the free variables in the expression. + + + Builds a 'for i = ... to ... do ...' expression that represent loops over integer ranges + The sub-expression declaring the loop variable. + The sub-expression setting the initial value of the loop variable. + The sub-expression declaring the final value of the loop variable. + The sub-expression representing the body of the loop. + The resulting expression. + + + Builds an expression that represents writing to a field of an object + The input object. + The description of the field to write to. + The value to set to the field. + The resulting expression. + + + Builds an expression that represents writing to a static field + The description of the field to write to. + The value to the set to the field. + The resulting expression. + + + Builds an expression that represents the access of a field of an object + The input object. + The description of the field to access. + The resulting expression. + + + Builds an expression that represents the access of a static field + The description of the field to access. + The resulting expression. + + + + + + This function is called automatically when quotation syntax (<@ @>) and related typed-expression + quotations are used. The bytes are a pickled binary representation of an unlinked form of the quoted expression, + and the System.Type argument is any type in the assembly where the quoted + expression occurs, i.e. it helps scope the interpretation of the cross-assembly + references in the bytes. + A type in the assembly where the quotation occurs. + The list of spliced types. + The list of spliced expressions. + The serialized form of the quoted expression. + The resulting expression. + + + Builds an expression that represents the invocation of a default object constructor + The type on which the constructor is invoked. + The resulting expression. + + + Builds an expression that represents the coercion of an expression to a type + The expression to coerce. + The target type. + The resulting expression. + + + Returns a new typed expression given an underlying runtime-typed expression. + A type annotation is usually required to use this function, and + using an incorrect type annotation may result in a later runtime exception. + The expression to cast. + The resulting typed expression. + + + Builds an expression that represents a call to an instance method associated with an object + The input object. + The description of the method to call. + The list of arguments to the method. + The resulting expression. + + + Builds an expression that represents a call to an static method or module-bound function + The MethodInfo describing the method to call. + The list of arguments to the method. + The resulting expression. + + + Builds an expression that represents the application of a first class function value to multiple arguments + The function to apply. + The list of lists of arguments to the function. + The resulting expression. + + + Builds an expression that represents the application of a first class function value to a single argument. + The function to apply. + The argument to the function. + The resulting expression. + + + Builds an expression that represents setting the value held at a particular address. + The target expression. + The value to set at the address. + The resulting expression. + + + Builds an expression that represents getting the address of a value. + The target expression. + The resulting expression. + + + Quoted expressions annotated with System.Type values. + + + The type associated with the variable + + + The declared name of the variable + + + Indicates if the variable represents a mutable storage location + + + Fetches or create a new variable with the given name and type from a global pool of shared variables + indexed by name and type + The name of the variable. + The type associated with the variable. + The retrieved or created variable. + + + Creates a new variable with the given name, type and mutability + The declared name of the variable. + The type associated with the variable. + Indicates if the variable represents a mutable storage location. Default is false. + The created variable. + + + Information at the binding site of a variable + + + Re-build combination expressions. The first parameter should be an object + returned by the ShapeCombination case of the active pattern in this module. + The input shape. + The list of arguments. + The rebuilt expression. + + + An active pattern that performs a complete decomposition viewing the expression tree as a binding structure + The input expression. + The decomposed Var, Lambda, or ConstApp. + + + Active patterns for traversing, visiting, rebuilding and tranforming expressions in a generic way + + + An active pattern to recognize property setters that have an associated ReflectedDefinition + The description of the property. + The expression of the method definition if found, or None. + + + An active pattern to recognize property getters or values in modules that have an associated ReflectedDefinition + The description of the property. + The expression of the method definition if found, or None. + + + An active pattern to recognize methods that have an associated ReflectedDefinition + The description of the method. + The expression of the method definition if found, or None. + + + A parameterized active pattern to recognize calls to a specified function or method. + The returned elements are the optional target object (present if the target is an + instance method), the generic type instantation (non-empty if the target is a generic + instantiation), and the arguments to the function or method. + The input template expression to specify the method to call. + The optional target object (present if the target is an + instance method), the generic type instantation (non-empty if the target is a generic + instantiation), and the arguments to the function or method. + + + An active pattern to recognize constant unsigned int64 expressions + The input expression to match against. + uint64 option + + + An active pattern to recognize constant int64 expressions + The input expression to match against. + int64 option + + + An active pattern to recognize constant unsigned int32 expressions + The input expression to match against. + uint32 option + + + An active pattern to recognize constant int32 expressions + The input expression to match against. + int32 option + + + An active pattern to recognize constant unsigned int16 expressions + The input expression to match against. + uint16 option + + + An active pattern to recognize constant int16 expressions + The input expression to match against. + int16 option + + + An active pattern to recognize constant byte expressions + The input expression to match against. + byte option + + + An active pattern to recognize constant signed byte expressions + The input expression to match against. + sbyte option + + + An active pattern to recognize constant unicode character expressions + The input expression to match against. + char option + + + An active pattern to recognize constant 64-bit floating point number expressions + The input expression to match against. + float option + + + An active pattern to recognize constant 32-bit floating point number expressions + The input expression to match against. + float32 option + + + An active pattern to recognize constant string expressions + The input expression to match against. + string option + + + An active pattern to recognize constant boolean expressions + The input expression to match against. + bool option + + + An active pattern to recognize () constant expressions + The input expression to match against. + unit option + + + An active pattern to recognize expressions of the form a || b + The input expression to match against. + (Expr * Expr) option + + + An active pattern to recognize expressions of the form a && b + The input expression to match against. + (Expr * Expr) option + + + An active pattern to recognize expressions that represent the application of a (possibly curried or tupled) first class function value + The input expression to match against. + (Expr * Expr list list) option + + + An active pattern to recognize expressions that represent a (possibly curried or tupled) first class function value + The input expression to match against. + (Var list list * Expr) option + + + Contains a set of derived F# active patterns to analyze F# expression objects + + + An active pattern to recognize expressions that represent setting a mutable variable + The input expression to match against. + (Var * Expr) option + + + An active pattern to recognize expressions that represent a variable + The input expression to match against. + Var option + + + An active pattern to recognize expressions that represent a constant value + The input expression to match against. + (obj * Type) option + + + An active pattern to recognize expressions that represent a test if a value is of a particular union case + The input expression to match against. + (Expr * UnionCaseInfo) option + + + An active pattern to recognize expressions that represent a dynamic type test + The input expression to match against. + (Expr * Type) option + + + An active pattern to recognize expressions that represent getting a tuple field + The input expression to match against. + (Expr * int) option + + + An active pattern to recognize expressions that represent a try/finally construct + The input expression to match against. + (Expr * Expr) option + + + An active pattern to recognize expressions that represent a try/with construct for exception filtering and catching + The input expression to match against. + (Expr * Var * Expr * Var * Expr) option + + + An active pattern to recognize expressions that represent sequential exeuction of one expression followed by another + The input expression to match against. + (Expr * Expr) option + + + An active pattern to recognize expressions that represent a nested quotation literal + The input expression to match against. + Expr option + + + An active pattern to recognize expressions that represent setting a static or instance property, or a non-function value declared in a module + The input expression to match against. + (Expr option * PropertyInfo * Expr list * Expr) option + + + An active pattern to recognize expressions that represent the read of a static or instance property, or a non-function value declared in a module + The input expression to match against. + (Expr option * PropertyInfo * Expr list) option + + + An active pattern to recognize expressions that represent construction of tuple values + The input expression to match against. + (Expr list) option + + + An active pattern to recognize expressions that represent construction of particular union case values + The input expression to match against. + (UnionCaseInfo * Expr list) option + + + An active pattern to recognize expressions that represent construction of record values + The input expression to match against. + (Type * Expr list) option + + + An active pattern to recognize expressions that represent invocation of object constructors + The input expression to match against. + (ConstructorInfo * Expr list) option + + + An active pattern to recognize expressions that represent construction of delegate values + The input expression to match against. + (Type * Var list * Expr) option + + + An active pattern to recognize expressions that represent invocations of a default constructor of a struct + The input expression to match against. + Type option + + + An active pattern to recognize expressions that represent the construction of arrays + The input expression to match against. + (Type * Expr list) option + + + An active pattern to recognize expressions that represent recursive let bindings of one or more variables + The input expression to match against. + ((Var * Expr) list * Expr) option + + + An active pattern to recognize expressions that represent let bindings + The input expression to match against. + (Var * Expr * Expr) option + + + An active pattern to recognize expressions that represent first class function values + The input expression to match against. + (Var * Expr) option + + + An active pattern to recognize expressions that represent conditionals + The input expression to match against. + (Expr * Expr * Expr) option + + + An active pattern to recognize expressions that represent while loops + The input expression to match against. + (Expr * Expr) option + + + An active pattern to recognize expressions that represent loops over integer ranges + The input expression to match against. + (Var * Expr * Expr * Expr) option + + + An active pattern to recognize expressions that represent setting a static or instance field + The input expression to match against. + (Expr option * FieldInfo * Expr) option + + + An active pattern to recognize expressions that represent getting a static or instance field + The input expression to match against. + (Expr option * FieldInfo) option + + + An active pattern to recognize expressions that represent coercions from one type to another + The input expression to match against. + (Expr * Type) option + + + An active pattern to recognize expressions that represent calls to static and instance methods, and functions defined in modules + The input expression to match against. + (Expr option * MethodInfo * Expr list) option + + + An active pattern to recognize expressions that represent applications of first class function values + The input expression to match against. + (Expr * Expr) option + + + An active pattern to recognize expressions that represent setting the value held at an address + The input expression to match against. + (Expr * Expr) option + + + An active pattern to recognize expressions that represent getting the address of a value + The input expression to match against. + Expr option + + + Contains a set of primitive F# active patterns to analyze F# expression objects + + + Returns a System.Type representing an F# tuple type with the given element types + An array of types for the tuple elements. + The type representing the tuple containing the input elements. + + + Returns a System.Type representing the F# function type with the given domain and range + The input type of the function. + The output type of the function. + The function type with the given domain and range. + + + Returns true if the typ is a representation of an F# union type or the runtime type of a value of that type + The type to check. + Optional binding flags. + True if the type check succeeds. + + + Return true if the typ is a representation of an F# tuple type + The type to check. + True if the type check succeeds. + + + Return true if the typ is a representation of an F# record type + The type to check. + Optional binding flags. + True if the type check succeeds. + + + Return true if the typ is a System.Type value corresponding to the compiled form of an F# module + The type to check. + True if the type check succeeds. + + + Return true if the typ is a representation of an F# function type or the runtime type of a closure implementing an F# function type + The type to check. + True if the type check succeeds. + + + Returns true if the typ is a representation of an F# exception declaration + The type to check. + Optional binding flags. + True if the type check is an F# exception. + + + Gets the cases of a union type. + + Assumes the given type is a union type. If not, ArgumentException is raised during pre-computation. + The input union type. + Optional binding flags. + Thrown when the input type is not a union type. + An array of descriptions of the cases of the given union type. + + + Gets the tuple elements from the representation of an F# tuple type. + The input tuple type. + An array of the types contained in the given tuple type. + + + Reads all the fields from a record value, in declaration order + + Assumes the given input is a record value. If not, ArgumentException is raised. + The input record type. + Optional binding flags. + An array of descriptions of the properties of the record type. + + + Gets the domain and range types from an F# function type or from the runtime type of a closure implementing an F# type + The input function type. + A tuple of the domain and range types of the input function. + + + Reads all the fields from an F# exception declaration, in declaration order + + Assumes exceptionType is an exception representation type. If not, ArgumentException is raised. + The exception type to read. + Optional binding flags. + Thrown if the given type is not an exception. + An array containing the PropertyInfo of each field in the exception. + + + Contains operations associated with constructing and analyzing F# types such as records, unions and tuples + + + Assumes the given type is a union type. + If not, ArgumentException is raised during pre-computation. + + Using the computed function is more efficient than calling GetUnionCase + because the path executed by the computed function is optimized given the knowledge that it will be + used to read values of the given type. + The type of union to optimize reading. + Optional binding flags. + An optimized function to read the tags of the given union type. + + + Precompute a property or static method for reading an integer representing the case tag of a union type. + The type of union to read. + Optional binding flags. + The description of the union case reader. + + + Precomputes a function for reading all the fields for a particular discriminator case of a union type + + Using the computed function will typically be faster than executing a corresponding call to GetFields + The description of the union case to read. + Optional binding flags. + A function to for reading the fields of the given union case. + + + A method that constructs objects of the given case + The description of the union case. + Optional binding flags. + The description of the constructor of the given union case. + + + Precomputes a function for constructing a discriminated union value for a particular union case. + The description of the union case. + Optional binding flags. + A function for constructing values of the given union case. + + + Precomputes a function for reading the values of a particular tuple type + + Assumes the given type is a TupleType. + If not, ArgumentException is raised during pre-computation. + The tuple type to read. + Thrown when the given type is not a tuple type. + A function to read values of the given tuple type. + + + Gets information that indicates how to read a field of a tuple + The input tuple type. + The index of the tuple element to describe. + The description of the tuple element and an optional type and index if the tuple is big. + + + Gets a method that constructs objects of the given tuple type. + For small tuples, no additional type will be returned. + + For large tuples, an additional type is returned indicating that + a nested encoding has been used for the tuple type. In this case + the suffix portion of the tuple type has the given type and an + object of this type must be created and passed as the last argument + to the ConstructorInfo. A recursive call to PreComputeTupleConstructorInfo + can be used to determine the constructor for that the suffix type. + The input tuple type. + The description of the tuple type constructor and an optional extra type + for large tuples. + + + Precomputes a function for reading the values of a particular tuple type + + Assumes the given type is a TupleType. + If not, ArgumentException is raised during pre-computation. + The type of tuple to read. + Thrown when the given type is not a tuple type. + A function to read a particular tuple type. + + + Precompute a function for reading all the fields from a record. The fields are returned in the + same order as the fields reported by a call to Microsoft.FSharp.Reflection.Type.GetInfo for + this type. + + Assumes the given type is a RecordType. + If not, ArgumentException is raised during pre-computation. + + Using the computed function will typically be faster than executing a corresponding call to Value.GetInfo + because the path executed by the computed function is optimized given the knowledge that it will be + used to read values of the given type. + The type of record to read. + Optional binding flags. + Thrown when the input type is not a record type. + An optimized reader for the given record type. + + + Precompute a function for reading a particular field from a record. + Assumes the given type is a RecordType with a field of the given name. + If not, ArgumentException is raised during pre-computation. + + Using the computed function will typically be faster than executing a corresponding call to Value.GetInfo + because the path executed by the computed function is optimized given the knowledge that it will be + used to read values of the given type. + The PropertyInfo of the field to read. + Thrown when the input type is not a record type. + A function to read the specified field from the record. + + + Get a ConstructorInfo for a record type + The record type. + Optional binding flags. + A ConstructorInfo for the given record type. + + + Precompute a function for constructing a record value. + + Assumes the given type is a RecordType. + If not, ArgumentException is raised during pre-computation. + The type of record to construct. + Optional binding flags. + Thrown when the input type is not a record type. + A function to construct records of the given type. + + + Create a union case value. + The description of the union case to create. + The array of arguments to construct the given case. + Optional binding flags. + The constructed union case. + + + Creates an instance of a tuple type + + Assumes at least one element is given. If not, ArgumentException is raised. + The array of tuple fields. + The tuple type to create. + Thrown if no elements are given. + An instance of the tuple type with the given elements. + + + Creates an instance of a record type. + + Assumes the given input is a record type. + The type of record to make. + The array of values to initialize the record. + Optional binding flags for the record. + Thrown when the input type is not a record type. + The created record. + + + Builds a typed function from object from a dynamic function implementation + The function type of the implementation. + The untyped lambda of the function implementation. + A typed function from the given dynamic implementation. + + + Identify the union case and its fields for an object + + Assumes the given input is a union case value. If not, ArgumentException is raised. + + If the type is not given, then the runtime type of the input object is used to identify the + relevant union type. The type should always be given if the input object may be null. For example, + option values may be represented using the 'null'. + The input union case. + The union type containing the value. + Optional binding flags. + Thrown when the input type is not a union case value. + The description of the union case and its fields. + + + Reads all fields from a tuple. + + Assumes the given input is a tuple value. If not, ArgumentException is raised. + The input tuple. + Thrown when the input is not a tuple value. + An array of the fields from the given tuple. + + + Reads a field from a tuple value. + + Assumes the given input is a tuple value. If not, ArgumentException is raised. + The input tuple. + The index of the field to read. + The value of the field. + + + Reads all the fields from a record value. + + Assumes the given input is a record value. If not, ArgumentException is raised. + The record object. + Optional binding flags for the record. + Thrown when the input type is not a record type. + The array of fields from the record. + + + Reads a field from a record value. + + Assumes the given input is a record value. If not, ArgumentException is raised. + The record object. + The PropertyInfo describing the field to read. + Thrown when the input type is not a record type. + The field from the record. + + + Reads all the fields from a value built using an instance of an F# exception declaration + + Assumes the given input is an F# exception value. If not, ArgumentException is raised. + The exception instance. + Optional binding flags. + Thrown when the input type is not an F# exception. + The fields from the given exception. + + + Contains operations associated with constructing and analyzing values associated with F# types + such as records, unions and tuples. + + + The integer tag for the case. + + + The name of the case. + + + The type in which the case occurs. + + + The fields associated with the case, represented by a PropertyInfo. + The fields associated with the case. + + + Returns the custom attributes associated with the case matching the given attribute type. + The type of attributes to return. + An array of custom attributes. + + + Returns the custom attributes associated with the case. + An array of custom attributes. + + + Represents a case of a discriminated union type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A record of options to control structural formatting. + For F# Interactive properties matching those of this value can be accessed via the 'fsi' + value. + + Floating Point format given in the same format accepted by System.Double.ToString, + e.g. f6 or g15. + + If ShowProperties is set the printing process will evaluate properties of the values being + displayed. This may cause additional computation. + + The ShowIEnumerable is set the printing process will force the evalution of IEnumerable objects + to a small, finite depth, as determined by the printing parameters. + This may lead to additional computation being performed during printing. + + <example> + From F# Interactive the default settings can be adjusted using, for example, + <pre> + open Microsoft.FSharp.Compiler.Interactive.Settings;; + setPrintWidth 120;; + </pre> + </example> + + + + + Data representing structured layouts of terms. + + + + + Convert any value to a layout using the given formatting options. The + layout can then be processed using formatting display engines such as + those in the LayoutOps module. any_to_string and output_any are + built using any_to_layout with default format options. + + + + + + + + Ouput any value to a channel using the same set of formatting rules + as any_to_string + + + + + Convert any value to a string using a standard formatter + Data is typically formatted in a structured format, e.g. + lists are formatted using the "[1;2]" notation. + The details of the format are not specified and may change + from version to version and according to the flags given + to the F# compiler. The format is intended to be human-readable, + not machine readable. If alternative generic formats are required + you should develop your own formatter, using the code in the + implementation of this file as a starting point. + + Data from other .NET languages is formatted using a virtual + call to Object.ToString() on the boxed version of the input. + + + + + + + + For limitting layout of list-like sequences (lists,arrays,etc). + unfold a list of items using (project and z) making layout list via itemL. + If reach maxLength (before exhausting) then truncate. + + + + + See tagL + + + + + Layout like an F# list. + + + + + Layout like an F# option. + + + + + Layout list vertically. + + + + + Layout two vertically. + + + + + Form tuple of layouts. + + + + + Wrap braces around layout. + + + + + Wrap square brackets around layout. + + + + + Wrap round brackets around Layout. + + + + + Join layouts into a list separated using the given Layout. + + + + + Join layouts into a semi-colon separated list. + + + + + Join layouts into a space separated list. + + + + + Join layouts into a comma separated list. + + + + + Join broken with ident=2 + + + + + Join broken with ident=1 + + + + + Join broken with ident=0 + + + + + Join, possible break with indent=2 + + + + + Join, possible break with indent=1 + + + + + Join, possible break with indent=0 + + + + + Join, unbreakable. + + + + + An string which is left parenthesis (no space on the right). + + + + + An string which is right parenthesis (no space on the left). + + + + + An string which requires no spaces either side. + + + + + An string leaf + + + + + An uninterpreted leaf, to be interpreted into a string + by the layout engine. This allows leaf layouts for numbers, strings and + other atoms to be customized according to culture. + + + + + Is it the empty layout? + + + + + The empty layout + + + + + A layout is a sequence of strings which have been joined together. + The strings are classified as words, separators and left and right parenthesis. + This classification determines where spaces are inserted. + A joint is either unbreakable, breakable or broken. + If a joint is broken the RHS layout occurs on the next line with optional indentation. + A layout can be squashed to for given width which forces breaks as required. + + + +